ovirtsdk4.readers

    1# -*- coding: utf-8 -*-
    2
    3#
    4# Copyright (c) 2016 Red Hat, Inc.
    5#
    6# Licensed under the Apache License, Version 2.0 (the "License");
    7# you may not use this file except in compliance with the License.
    8# You may obtain a copy of the License at
    9#
   10#   http://www.apache.org/licenses/LICENSE-2.0
   11#
   12# Unless required by applicable law or agreed to in writing, software
   13# distributed under the License is distributed on an "AS IS" BASIS,
   14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   15# See the License for the specific language governing permissions and
   16# limitations under the License.
   17#
   18
   19
   20from ovirtsdk4 import List
   21from ovirtsdk4 import types
   22from ovirtsdk4.reader import Reader
   23
   24
   25class ActionReader(Reader):
   26
   27    def __init__(self):
   28        super(ActionReader, self).__init__()
   29
   30    @staticmethod
   31    def read_one(reader):
   32        # Do nothing if there aren't more tags:
   33        if not reader.forward():
   34            return None
   35
   36        # Create the object:
   37        obj = types.Action()
   38
   39        # Process the attributes:
   40        obj.href = reader.get_attribute('href')
   41        value = reader.get_attribute('id')
   42        if value is not None:
   43            obj.id = value
   44
   45        # Discard the start tag:
   46        empty = reader.empty_element()
   47        reader.read()
   48        if empty:
   49            return obj
   50
   51        # Process the inner elements:
   52        links = []
   53        while reader.forward():
   54            tag = reader.node_name()
   55            if tag == 'activate':
   56                obj.activate = Reader.read_boolean(reader)
   57            elif tag == 'allow_partial_import':
   58                obj.allow_partial_import = Reader.read_boolean(reader)
   59            elif tag == 'async':
   60                obj.async_ = Reader.read_boolean(reader)
   61            elif tag == 'attachment':
   62                obj.attachment = DiskAttachmentReader.read_one(reader)
   63            elif tag == 'authorized_key':
   64                obj.authorized_key = AuthorizedKeyReader.read_one(reader)
   65            elif tag == 'auto_pinning_policy':
   66                obj.auto_pinning_policy = Reader.read_enum(types.AutoPinningPolicy, reader)
   67            elif tag == 'bricks':
   68                obj.bricks = GlusterBrickReader.read_many(reader)
   69            elif tag == 'certificates':
   70                obj.certificates = CertificateReader.read_many(reader)
   71            elif tag == 'check_connectivity':
   72                obj.check_connectivity = Reader.read_boolean(reader)
   73            elif tag == 'clone':
   74                obj.clone = Reader.read_boolean(reader)
   75            elif tag == 'clone_permissions':
   76                obj.clone_permissions = Reader.read_boolean(reader)
   77            elif tag == 'cluster':
   78                obj.cluster = ClusterReader.read_one(reader)
   79            elif tag == 'collapse_snapshots':
   80                obj.collapse_snapshots = Reader.read_boolean(reader)
   81            elif tag == 'comment':
   82                obj.comment = Reader.read_string(reader)
   83            elif tag == 'commit_on_success':
   84                obj.commit_on_success = Reader.read_boolean(reader)
   85            elif tag == 'connection':
   86                obj.connection = StorageConnectionReader.read_one(reader)
   87            elif tag == 'connectivity_timeout':
   88                obj.connectivity_timeout = Reader.read_integer(reader)
   89            elif tag == 'correlation_id':
   90                obj.correlation_id = Reader.read_string(reader)
   91            elif tag == 'data_center':
   92                obj.data_center = DataCenterReader.read_one(reader)
   93            elif tag == 'deploy_hosted_engine':
   94                obj.deploy_hosted_engine = Reader.read_boolean(reader)
   95            elif tag == 'description':
   96                obj.description = Reader.read_string(reader)
   97            elif tag == 'details':
   98                obj.details = GlusterVolumeProfileDetailsReader.read_one(reader)
   99            elif tag == 'directory':
  100                obj.directory = Reader.read_string(reader)
  101            elif tag == 'discard_snapshots':
  102                obj.discard_snapshots = Reader.read_boolean(reader)
  103            elif tag == 'discovered_targets':
  104                obj.discovered_targets = IscsiDetailsReader.read_many(reader)
  105            elif tag == 'disk':
  106                obj.disk = DiskReader.read_one(reader)
  107            elif tag == 'disk_profile':
  108                obj.disk_profile = DiskProfileReader.read_one(reader)
  109            elif tag == 'disks':
  110                obj.disks = DiskReader.read_many(reader)
  111            elif tag == 'exclusive':
  112                obj.exclusive = Reader.read_boolean(reader)
  113            elif tag == 'fault':
  114                obj.fault = FaultReader.read_one(reader)
  115            elif tag == 'fence_type':
  116                obj.fence_type = Reader.read_string(reader)
  117            elif tag == 'filename':
  118                obj.filename = Reader.read_string(reader)
  119            elif tag == 'filter':
  120                obj.filter = Reader.read_boolean(reader)
  121            elif tag == 'fix_layout':
  122                obj.fix_layout = Reader.read_boolean(reader)
  123            elif tag == 'follow':
  124                obj.follow = Reader.read_string(reader)
  125            elif tag == 'force':
  126                obj.force = Reader.read_boolean(reader)
  127            elif tag == 'grace_period':
  128                obj.grace_period = GracePeriodReader.read_one(reader)
  129            elif tag == 'host':
  130                obj.host = HostReader.read_one(reader)
  131            elif tag == 'image':
  132                obj.image = Reader.read_string(reader)
  133            elif tag == 'image_transfer':
  134                obj.image_transfer = ImageTransferReader.read_one(reader)
  135            elif tag == 'import_as_template':
  136                obj.import_as_template = Reader.read_boolean(reader)
  137            elif tag == 'is_attached':
  138                obj.is_attached = Reader.read_boolean(reader)
  139            elif tag == 'iscsi':
  140                obj.iscsi = IscsiDetailsReader.read_one(reader)
  141            elif tag == 'iscsi_targets':
  142                obj.iscsi_targets = Reader.read_strings(reader)
  143            elif tag == 'job':
  144                obj.job = JobReader.read_one(reader)
  145            elif tag == 'lease':
  146                obj.lease = StorageDomainLeaseReader.read_one(reader)
  147            elif tag == 'logical_units':
  148                obj.logical_units = LogicalUnitReader.read_many(reader)
  149            elif tag == 'maintenance_after_restart':
  150                obj.maintenance_after_restart = Reader.read_boolean(reader)
  151            elif tag == 'maintenance_enabled':
  152                obj.maintenance_enabled = Reader.read_boolean(reader)
  153            elif tag == 'migrate_vms_in_affinity_closure':
  154                obj.migrate_vms_in_affinity_closure = Reader.read_boolean(reader)
  155            elif tag == 'modified_bonds':
  156                obj.modified_bonds = HostNicReader.read_many(reader)
  157            elif tag == 'modified_labels':
  158                obj.modified_labels = NetworkLabelReader.read_many(reader)
  159            elif tag == 'modified_network_attachments':
  160                obj.modified_network_attachments = NetworkAttachmentReader.read_many(reader)
  161            elif tag == 'name':
  162                obj.name = Reader.read_string(reader)
  163            elif tag == 'optimize_cpu_settings':
  164                obj.optimize_cpu_settings = Reader.read_boolean(reader)
  165            elif tag == 'option':
  166                obj.option = OptionReader.read_one(reader)
  167            elif tag == 'pause':
  168                obj.pause = Reader.read_boolean(reader)
  169            elif tag == 'permission':
  170                obj.permission = PermissionReader.read_one(reader)
  171            elif tag == 'power_management':
  172                obj.power_management = PowerManagementReader.read_one(reader)
  173            elif tag == 'proxy_ticket':
  174                obj.proxy_ticket = ProxyTicketReader.read_one(reader)
  175            elif tag == 'quota':
  176                obj.quota = QuotaReader.read_one(reader)
  177            elif tag == 'reason':
  178                obj.reason = Reader.read_string(reader)
  179            elif tag == 'reassign_bad_macs':
  180                obj.reassign_bad_macs = Reader.read_boolean(reader)
  181            elif tag == 'reboot':
  182                obj.reboot = Reader.read_boolean(reader)
  183            elif tag == 'registration_configuration':
  184                obj.registration_configuration = RegistrationConfigurationReader.read_one(reader)
  185            elif tag == 'remote_viewer_connection_file':
  186                obj.remote_viewer_connection_file = Reader.read_string(reader)
  187            elif tag == 'removed_bonds':
  188                obj.removed_bonds = HostNicReader.read_many(reader)
  189            elif tag == 'removed_labels':
  190                obj.removed_labels = NetworkLabelReader.read_many(reader)
  191            elif tag == 'removed_network_attachments':
  192                obj.removed_network_attachments = NetworkAttachmentReader.read_many(reader)
  193            elif tag == 'resolution_type':
  194                obj.resolution_type = Reader.read_string(reader)
  195            elif tag == 'restore_memory':
  196                obj.restore_memory = Reader.read_boolean(reader)
  197            elif tag == 'root_password':
  198                obj.root_password = Reader.read_string(reader)
  199            elif tag == 'seal':
  200                obj.seal = Reader.read_boolean(reader)
  201            elif tag == 'snapshot':
  202                obj.snapshot = SnapshotReader.read_one(reader)
  203            elif tag == 'source_host':
  204                obj.source_host = HostReader.read_one(reader)
  205            elif tag == 'ssh':
  206                obj.ssh = SshReader.read_one(reader)
  207            elif tag == 'status':
  208                obj.status = Reader.read_string(reader)
  209            elif tag == 'stop_gluster_service':
  210                obj.stop_gluster_service = Reader.read_boolean(reader)
  211            elif tag == 'storage_domain':
  212                obj.storage_domain = StorageDomainReader.read_one(reader)
  213            elif tag == 'storage_domains':
  214                obj.storage_domains = StorageDomainReader.read_many(reader)
  215            elif tag == 'succeeded':
  216                obj.succeeded = Reader.read_boolean(reader)
  217            elif tag == 'synchronized_network_attachments':
  218                obj.synchronized_network_attachments = NetworkAttachmentReader.read_many(reader)
  219            elif tag == 'template':
  220                obj.template = TemplateReader.read_one(reader)
  221            elif tag == 'ticket':
  222                obj.ticket = TicketReader.read_one(reader)
  223            elif tag == 'timeout':
  224                obj.timeout = Reader.read_integer(reader)
  225            elif tag == 'undeploy_hosted_engine':
  226                obj.undeploy_hosted_engine = Reader.read_boolean(reader)
  227            elif tag == 'upgrade_action':
  228                obj.upgrade_action = Reader.read_enum(types.ClusterUpgradeAction, reader)
  229            elif tag == 'upgrade_percent_complete':
  230                obj.upgrade_percent_complete = Reader.read_integer(reader)
  231            elif tag == 'use_cloud_init':
  232                obj.use_cloud_init = Reader.read_boolean(reader)
  233            elif tag == 'use_ignition':
  234                obj.use_ignition = Reader.read_boolean(reader)
  235            elif tag == 'use_initialization':
  236                obj.use_initialization = Reader.read_boolean(reader)
  237            elif tag == 'use_sysprep':
  238                obj.use_sysprep = Reader.read_boolean(reader)
  239            elif tag == 'virtual_functions_configuration':
  240                obj.virtual_functions_configuration = HostNicVirtualFunctionsConfigurationReader.read_one(reader)
  241            elif tag == 'vm':
  242                obj.vm = VmReader.read_one(reader)
  243            elif tag == 'vnic_profile_mappings':
  244                obj.vnic_profile_mappings = VnicProfileMappingReader.read_many(reader)
  245            elif tag == 'volatile':
  246                obj.volatile = Reader.read_boolean(reader)
  247            else:
  248                reader.next_element()
  249        for link in links:
  250            ActionReader._process_link(link, obj)
  251
  252        # Discard the end tag:
  253        reader.read()
  254
  255        return obj
  256
  257    @staticmethod
  258    def read_many(reader):
  259        # Do nothing if there aren't more tags:
  260        objs = List()
  261        if not reader.forward():
  262            return objs
  263
  264        # Process the attributes:
  265        objs.href = reader.get_attribute('href')
  266
  267        # Discard the start tag:
  268        empty = reader.empty_element()
  269        reader.read()
  270        if empty:
  271            return objs
  272
  273        # Process the inner elements:
  274        while reader.forward():
  275            objs.append(ActionReader.read_one(reader))
  276
  277        # Discard the end tag:
  278        reader.read()
  279
  280        return objs
  281
  282
  283class AffinityGroupReader(Reader):
  284
  285    def __init__(self):
  286        super(AffinityGroupReader, self).__init__()
  287
  288    @staticmethod
  289    def read_one(reader):
  290        # Do nothing if there aren't more tags:
  291        if not reader.forward():
  292            return None
  293
  294        # Create the object:
  295        obj = types.AffinityGroup()
  296
  297        # Process the attributes:
  298        obj.href = reader.get_attribute('href')
  299        value = reader.get_attribute('id')
  300        if value is not None:
  301            obj.id = value
  302
  303        # Discard the start tag:
  304        empty = reader.empty_element()
  305        reader.read()
  306        if empty:
  307            return obj
  308
  309        # Process the inner elements:
  310        links = []
  311        while reader.forward():
  312            tag = reader.node_name()
  313            if tag == 'broken':
  314                obj.broken = Reader.read_boolean(reader)
  315            elif tag == 'cluster':
  316                obj.cluster = ClusterReader.read_one(reader)
  317            elif tag == 'comment':
  318                obj.comment = Reader.read_string(reader)
  319            elif tag == 'description':
  320                obj.description = Reader.read_string(reader)
  321            elif tag == 'enforcing':
  322                obj.enforcing = Reader.read_boolean(reader)
  323            elif tag == 'host_labels':
  324                obj.host_labels = AffinityLabelReader.read_many(reader)
  325            elif tag == 'hosts':
  326                obj.hosts = HostReader.read_many(reader)
  327            elif tag == 'hosts_rule':
  328                obj.hosts_rule = AffinityRuleReader.read_one(reader)
  329            elif tag == 'name':
  330                obj.name = Reader.read_string(reader)
  331            elif tag == 'positive':
  332                obj.positive = Reader.read_boolean(reader)
  333            elif tag == 'priority':
  334                obj.priority = Reader.read_decimal(reader)
  335            elif tag == 'vm_labels':
  336                obj.vm_labels = AffinityLabelReader.read_many(reader)
  337            elif tag == 'vms':
  338                obj.vms = VmReader.read_many(reader)
  339            elif tag == 'vms_rule':
  340                obj.vms_rule = AffinityRuleReader.read_one(reader)
  341            elif tag == 'link':
  342                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
  343                reader.next_element()
  344            else:
  345                reader.next_element()
  346        for link in links:
  347            AffinityGroupReader._process_link(link, obj)
  348
  349        # Discard the end tag:
  350        reader.read()
  351
  352        return obj
  353
  354    @staticmethod
  355    def read_many(reader):
  356        # Do nothing if there aren't more tags:
  357        objs = List()
  358        if not reader.forward():
  359            return objs
  360
  361        # Process the attributes:
  362        objs.href = reader.get_attribute('href')
  363
  364        # Discard the start tag:
  365        empty = reader.empty_element()
  366        reader.read()
  367        if empty:
  368            return objs
  369
  370        # Process the inner elements:
  371        while reader.forward():
  372            objs.append(AffinityGroupReader.read_one(reader))
  373
  374        # Discard the end tag:
  375        reader.read()
  376
  377        return objs
  378
  379    @staticmethod
  380    def _process_link(link, obj):
  381        # Process the attributes:
  382        rel = link[0]
  383        href = link[1]
  384        if href and rel:
  385            if rel == "hostlabels":
  386                if obj.host_labels is not None:
  387                    obj.host_labels.href = href
  388                else:
  389                    obj.host_labels = List(href)
  390            elif rel == "hosts":
  391                if obj.hosts is not None:
  392                    obj.hosts.href = href
  393                else:
  394                    obj.hosts = List(href)
  395            elif rel == "vmlabels":
  396                if obj.vm_labels is not None:
  397                    obj.vm_labels.href = href
  398                else:
  399                    obj.vm_labels = List(href)
  400            elif rel == "vms":
  401                if obj.vms is not None:
  402                    obj.vms.href = href
  403                else:
  404                    obj.vms = List(href)
  405
  406
  407class AffinityLabelReader(Reader):
  408
  409    def __init__(self):
  410        super(AffinityLabelReader, self).__init__()
  411
  412    @staticmethod
  413    def read_one(reader):
  414        # Do nothing if there aren't more tags:
  415        if not reader.forward():
  416            return None
  417
  418        # Create the object:
  419        obj = types.AffinityLabel()
  420
  421        # Process the attributes:
  422        obj.href = reader.get_attribute('href')
  423        value = reader.get_attribute('id')
  424        if value is not None:
  425            obj.id = value
  426
  427        # Discard the start tag:
  428        empty = reader.empty_element()
  429        reader.read()
  430        if empty:
  431            return obj
  432
  433        # Process the inner elements:
  434        links = []
  435        while reader.forward():
  436            tag = reader.node_name()
  437            if tag == 'comment':
  438                obj.comment = Reader.read_string(reader)
  439            elif tag == 'description':
  440                obj.description = Reader.read_string(reader)
  441            elif tag == 'has_implicit_affinity_group':
  442                obj.has_implicit_affinity_group = Reader.read_boolean(reader)
  443            elif tag == 'hosts':
  444                obj.hosts = HostReader.read_many(reader)
  445            elif tag == 'name':
  446                obj.name = Reader.read_string(reader)
  447            elif tag == 'read_only':
  448                obj.read_only = Reader.read_boolean(reader)
  449            elif tag == 'vms':
  450                obj.vms = VmReader.read_many(reader)
  451            elif tag == 'link':
  452                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
  453                reader.next_element()
  454            else:
  455                reader.next_element()
  456        for link in links:
  457            AffinityLabelReader._process_link(link, obj)
  458
  459        # Discard the end tag:
  460        reader.read()
  461
  462        return obj
  463
  464    @staticmethod
  465    def read_many(reader):
  466        # Do nothing if there aren't more tags:
  467        objs = List()
  468        if not reader.forward():
  469            return objs
  470
  471        # Process the attributes:
  472        objs.href = reader.get_attribute('href')
  473
  474        # Discard the start tag:
  475        empty = reader.empty_element()
  476        reader.read()
  477        if empty:
  478            return objs
  479
  480        # Process the inner elements:
  481        while reader.forward():
  482            objs.append(AffinityLabelReader.read_one(reader))
  483
  484        # Discard the end tag:
  485        reader.read()
  486
  487        return objs
  488
  489    @staticmethod
  490    def _process_link(link, obj):
  491        # Process the attributes:
  492        rel = link[0]
  493        href = link[1]
  494        if href and rel:
  495            if rel == "hosts":
  496                if obj.hosts is not None:
  497                    obj.hosts.href = href
  498                else:
  499                    obj.hosts = List(href)
  500            elif rel == "vms":
  501                if obj.vms is not None:
  502                    obj.vms.href = href
  503                else:
  504                    obj.vms = List(href)
  505
  506
  507class AffinityRuleReader(Reader):
  508
  509    def __init__(self):
  510        super(AffinityRuleReader, self).__init__()
  511
  512    @staticmethod
  513    def read_one(reader):
  514        # Do nothing if there aren't more tags:
  515        if not reader.forward():
  516            return None
  517
  518        # Create the object:
  519        obj = types.AffinityRule()
  520
  521        # Process the attributes:
  522        obj.href = reader.get_attribute('href')
  523
  524        # Discard the start tag:
  525        empty = reader.empty_element()
  526        reader.read()
  527        if empty:
  528            return obj
  529
  530        # Process the inner elements:
  531        links = []
  532        while reader.forward():
  533            tag = reader.node_name()
  534            if tag == 'enabled':
  535                obj.enabled = Reader.read_boolean(reader)
  536            elif tag == 'enforcing':
  537                obj.enforcing = Reader.read_boolean(reader)
  538            elif tag == 'positive':
  539                obj.positive = Reader.read_boolean(reader)
  540            else:
  541                reader.next_element()
  542        for link in links:
  543            AffinityRuleReader._process_link(link, obj)
  544
  545        # Discard the end tag:
  546        reader.read()
  547
  548        return obj
  549
  550    @staticmethod
  551    def read_many(reader):
  552        # Do nothing if there aren't more tags:
  553        objs = List()
  554        if not reader.forward():
  555            return objs
  556
  557        # Process the attributes:
  558        objs.href = reader.get_attribute('href')
  559
  560        # Discard the start tag:
  561        empty = reader.empty_element()
  562        reader.read()
  563        if empty:
  564            return objs
  565
  566        # Process the inner elements:
  567        while reader.forward():
  568            objs.append(AffinityRuleReader.read_one(reader))
  569
  570        # Discard the end tag:
  571        reader.read()
  572
  573        return objs
  574
  575
  576class AgentReader(Reader):
  577
  578    def __init__(self):
  579        super(AgentReader, self).__init__()
  580
  581    @staticmethod
  582    def read_one(reader):
  583        # Do nothing if there aren't more tags:
  584        if not reader.forward():
  585            return None
  586
  587        # Create the object:
  588        obj = types.Agent()
  589
  590        # Process the attributes:
  591        obj.href = reader.get_attribute('href')
  592        value = reader.get_attribute('id')
  593        if value is not None:
  594            obj.id = value
  595
  596        # Discard the start tag:
  597        empty = reader.empty_element()
  598        reader.read()
  599        if empty:
  600            return obj
  601
  602        # Process the inner elements:
  603        links = []
  604        while reader.forward():
  605            tag = reader.node_name()
  606            if tag == 'address':
  607                obj.address = Reader.read_string(reader)
  608            elif tag == 'comment':
  609                obj.comment = Reader.read_string(reader)
  610            elif tag == 'concurrent':
  611                obj.concurrent = Reader.read_boolean(reader)
  612            elif tag == 'description':
  613                obj.description = Reader.read_string(reader)
  614            elif tag == 'encrypt_options':
  615                obj.encrypt_options = Reader.read_boolean(reader)
  616            elif tag == 'host':
  617                obj.host = HostReader.read_one(reader)
  618            elif tag == 'name':
  619                obj.name = Reader.read_string(reader)
  620            elif tag == 'options':
  621                obj.options = OptionReader.read_many(reader)
  622            elif tag == 'order':
  623                obj.order = Reader.read_integer(reader)
  624            elif tag == 'password':
  625                obj.password = Reader.read_string(reader)
  626            elif tag == 'port':
  627                obj.port = Reader.read_integer(reader)
  628            elif tag == 'type':
  629                obj.type = Reader.read_string(reader)
  630            elif tag == 'username':
  631                obj.username = Reader.read_string(reader)
  632            else:
  633                reader.next_element()
  634        for link in links:
  635            AgentReader._process_link(link, obj)
  636
  637        # Discard the end tag:
  638        reader.read()
  639
  640        return obj
  641
  642    @staticmethod
  643    def read_many(reader):
  644        # Do nothing if there aren't more tags:
  645        objs = List()
  646        if not reader.forward():
  647            return objs
  648
  649        # Process the attributes:
  650        objs.href = reader.get_attribute('href')
  651
  652        # Discard the start tag:
  653        empty = reader.empty_element()
  654        reader.read()
  655        if empty:
  656            return objs
  657
  658        # Process the inner elements:
  659        while reader.forward():
  660            objs.append(AgentReader.read_one(reader))
  661
  662        # Discard the end tag:
  663        reader.read()
  664
  665        return objs
  666
  667
  668class AgentConfigurationReader(Reader):
  669
  670    def __init__(self):
  671        super(AgentConfigurationReader, self).__init__()
  672
  673    @staticmethod
  674    def read_one(reader):
  675        # Do nothing if there aren't more tags:
  676        if not reader.forward():
  677            return None
  678
  679        # Create the object:
  680        obj = types.AgentConfiguration()
  681
  682        # Process the attributes:
  683        obj.href = reader.get_attribute('href')
  684
  685        # Discard the start tag:
  686        empty = reader.empty_element()
  687        reader.read()
  688        if empty:
  689            return obj
  690
  691        # Process the inner elements:
  692        links = []
  693        while reader.forward():
  694            tag = reader.node_name()
  695            if tag == 'address':
  696                obj.address = Reader.read_string(reader)
  697            elif tag == 'broker_type':
  698                obj.broker_type = Reader.read_enum(types.MessageBrokerType, reader)
  699            elif tag == 'network_mappings':
  700                obj.network_mappings = Reader.read_string(reader)
  701            elif tag == 'password':
  702                obj.password = Reader.read_string(reader)
  703            elif tag == 'port':
  704                obj.port = Reader.read_integer(reader)
  705            elif tag == 'username':
  706                obj.username = Reader.read_string(reader)
  707            else:
  708                reader.next_element()
  709        for link in links:
  710            AgentConfigurationReader._process_link(link, obj)
  711
  712        # Discard the end tag:
  713        reader.read()
  714
  715        return obj
  716
  717    @staticmethod
  718    def read_many(reader):
  719        # Do nothing if there aren't more tags:
  720        objs = List()
  721        if not reader.forward():
  722            return objs
  723
  724        # Process the attributes:
  725        objs.href = reader.get_attribute('href')
  726
  727        # Discard the start tag:
  728        empty = reader.empty_element()
  729        reader.read()
  730        if empty:
  731            return objs
  732
  733        # Process the inner elements:
  734        while reader.forward():
  735            objs.append(AgentConfigurationReader.read_one(reader))
  736
  737        # Discard the end tag:
  738        reader.read()
  739
  740        return objs
  741
  742
  743class ApiReader(Reader):
  744
  745    def __init__(self):
  746        super(ApiReader, self).__init__()
  747
  748    @staticmethod
  749    def read_one(reader):
  750        # Do nothing if there aren't more tags:
  751        if not reader.forward():
  752            return None
  753
  754        # Create the object:
  755        obj = types.Api()
  756
  757        # Process the attributes:
  758        obj.href = reader.get_attribute('href')
  759
  760        # Discard the start tag:
  761        empty = reader.empty_element()
  762        reader.read()
  763        if empty:
  764            return obj
  765
  766        # Process the inner elements:
  767        links = []
  768        while reader.forward():
  769            tag = reader.node_name()
  770            if tag == 'authenticated_user':
  771                obj.authenticated_user = UserReader.read_one(reader)
  772            elif tag == 'effective_user':
  773                obj.effective_user = UserReader.read_one(reader)
  774            elif tag == 'product_info':
  775                obj.product_info = ProductInfoReader.read_one(reader)
  776            elif tag == 'special_objects':
  777                obj.special_objects = SpecialObjectsReader.read_one(reader)
  778            elif tag == 'summary':
  779                obj.summary = ApiSummaryReader.read_one(reader)
  780            elif tag == 'time':
  781                obj.time = Reader.read_date(reader)
  782            else:
  783                reader.next_element()
  784        for link in links:
  785            ApiReader._process_link(link, obj)
  786
  787        # Discard the end tag:
  788        reader.read()
  789
  790        return obj
  791
  792    @staticmethod
  793    def read_many(reader):
  794        # Do nothing if there aren't more tags:
  795        objs = List()
  796        if not reader.forward():
  797            return objs
  798
  799        # Process the attributes:
  800        objs.href = reader.get_attribute('href')
  801
  802        # Discard the start tag:
  803        empty = reader.empty_element()
  804        reader.read()
  805        if empty:
  806            return objs
  807
  808        # Process the inner elements:
  809        while reader.forward():
  810            objs.append(ApiReader.read_one(reader))
  811
  812        # Discard the end tag:
  813        reader.read()
  814
  815        return objs
  816
  817
  818class ApiSummaryReader(Reader):
  819
  820    def __init__(self):
  821        super(ApiSummaryReader, self).__init__()
  822
  823    @staticmethod
  824    def read_one(reader):
  825        # Do nothing if there aren't more tags:
  826        if not reader.forward():
  827            return None
  828
  829        # Create the object:
  830        obj = types.ApiSummary()
  831
  832        # Process the attributes:
  833        obj.href = reader.get_attribute('href')
  834
  835        # Discard the start tag:
  836        empty = reader.empty_element()
  837        reader.read()
  838        if empty:
  839            return obj
  840
  841        # Process the inner elements:
  842        links = []
  843        while reader.forward():
  844            tag = reader.node_name()
  845            if tag == 'hosts':
  846                obj.hosts = ApiSummaryItemReader.read_one(reader)
  847            elif tag == 'storage_domains':
  848                obj.storage_domains = ApiSummaryItemReader.read_one(reader)
  849            elif tag == 'users':
  850                obj.users = ApiSummaryItemReader.read_one(reader)
  851            elif tag == 'vms':
  852                obj.vms = ApiSummaryItemReader.read_one(reader)
  853            else:
  854                reader.next_element()
  855        for link in links:
  856            ApiSummaryReader._process_link(link, obj)
  857
  858        # Discard the end tag:
  859        reader.read()
  860
  861        return obj
  862
  863    @staticmethod
  864    def read_many(reader):
  865        # Do nothing if there aren't more tags:
  866        objs = List()
  867        if not reader.forward():
  868            return objs
  869
  870        # Process the attributes:
  871        objs.href = reader.get_attribute('href')
  872
  873        # Discard the start tag:
  874        empty = reader.empty_element()
  875        reader.read()
  876        if empty:
  877            return objs
  878
  879        # Process the inner elements:
  880        while reader.forward():
  881            objs.append(ApiSummaryReader.read_one(reader))
  882
  883        # Discard the end tag:
  884        reader.read()
  885
  886        return objs
  887
  888
  889class ApiSummaryItemReader(Reader):
  890
  891    def __init__(self):
  892        super(ApiSummaryItemReader, self).__init__()
  893
  894    @staticmethod
  895    def read_one(reader):
  896        # Do nothing if there aren't more tags:
  897        if not reader.forward():
  898            return None
  899
  900        # Create the object:
  901        obj = types.ApiSummaryItem()
  902
  903        # Process the attributes:
  904        obj.href = reader.get_attribute('href')
  905
  906        # Discard the start tag:
  907        empty = reader.empty_element()
  908        reader.read()
  909        if empty:
  910            return obj
  911
  912        # Process the inner elements:
  913        links = []
  914        while reader.forward():
  915            tag = reader.node_name()
  916            if tag == 'active':
  917                obj.active = Reader.read_integer(reader)
  918            elif tag == 'total':
  919                obj.total = Reader.read_integer(reader)
  920            else:
  921                reader.next_element()
  922        for link in links:
  923            ApiSummaryItemReader._process_link(link, obj)
  924
  925        # Discard the end tag:
  926        reader.read()
  927
  928        return obj
  929
  930    @staticmethod
  931    def read_many(reader):
  932        # Do nothing if there aren't more tags:
  933        objs = List()
  934        if not reader.forward():
  935            return objs
  936
  937        # Process the attributes:
  938        objs.href = reader.get_attribute('href')
  939
  940        # Discard the start tag:
  941        empty = reader.empty_element()
  942        reader.read()
  943        if empty:
  944            return objs
  945
  946        # Process the inner elements:
  947        while reader.forward():
  948            objs.append(ApiSummaryItemReader.read_one(reader))
  949
  950        # Discard the end tag:
  951        reader.read()
  952
  953        return objs
  954
  955
  956class ApplicationReader(Reader):
  957
  958    def __init__(self):
  959        super(ApplicationReader, self).__init__()
  960
  961    @staticmethod
  962    def read_one(reader):
  963        # Do nothing if there aren't more tags:
  964        if not reader.forward():
  965            return None
  966
  967        # Create the object:
  968        obj = types.Application()
  969
  970        # Process the attributes:
  971        obj.href = reader.get_attribute('href')
  972        value = reader.get_attribute('id')
  973        if value is not None:
  974            obj.id = value
  975
  976        # Discard the start tag:
  977        empty = reader.empty_element()
  978        reader.read()
  979        if empty:
  980            return obj
  981
  982        # Process the inner elements:
  983        links = []
  984        while reader.forward():
  985            tag = reader.node_name()
  986            if tag == 'comment':
  987                obj.comment = Reader.read_string(reader)
  988            elif tag == 'description':
  989                obj.description = Reader.read_string(reader)
  990            elif tag == 'name':
  991                obj.name = Reader.read_string(reader)
  992            elif tag == 'vm':
  993                obj.vm = VmReader.read_one(reader)
  994            else:
  995                reader.next_element()
  996        for link in links:
  997            ApplicationReader._process_link(link, obj)
  998
  999        # Discard the end tag:
 1000        reader.read()
 1001
 1002        return obj
 1003
 1004    @staticmethod
 1005    def read_many(reader):
 1006        # Do nothing if there aren't more tags:
 1007        objs = List()
 1008        if not reader.forward():
 1009            return objs
 1010
 1011        # Process the attributes:
 1012        objs.href = reader.get_attribute('href')
 1013
 1014        # Discard the start tag:
 1015        empty = reader.empty_element()
 1016        reader.read()
 1017        if empty:
 1018            return objs
 1019
 1020        # Process the inner elements:
 1021        while reader.forward():
 1022            objs.append(ApplicationReader.read_one(reader))
 1023
 1024        # Discard the end tag:
 1025        reader.read()
 1026
 1027        return objs
 1028
 1029
 1030class AuthorizedKeyReader(Reader):
 1031
 1032    def __init__(self):
 1033        super(AuthorizedKeyReader, self).__init__()
 1034
 1035    @staticmethod
 1036    def read_one(reader):
 1037        # Do nothing if there aren't more tags:
 1038        if not reader.forward():
 1039            return None
 1040
 1041        # Create the object:
 1042        obj = types.AuthorizedKey()
 1043
 1044        # Process the attributes:
 1045        obj.href = reader.get_attribute('href')
 1046        value = reader.get_attribute('id')
 1047        if value is not None:
 1048            obj.id = value
 1049
 1050        # Discard the start tag:
 1051        empty = reader.empty_element()
 1052        reader.read()
 1053        if empty:
 1054            return obj
 1055
 1056        # Process the inner elements:
 1057        links = []
 1058        while reader.forward():
 1059            tag = reader.node_name()
 1060            if tag == 'comment':
 1061                obj.comment = Reader.read_string(reader)
 1062            elif tag == 'description':
 1063                obj.description = Reader.read_string(reader)
 1064            elif tag == 'key':
 1065                obj.key = Reader.read_string(reader)
 1066            elif tag == 'name':
 1067                obj.name = Reader.read_string(reader)
 1068            elif tag == 'user':
 1069                obj.user = UserReader.read_one(reader)
 1070            else:
 1071                reader.next_element()
 1072        for link in links:
 1073            AuthorizedKeyReader._process_link(link, obj)
 1074
 1075        # Discard the end tag:
 1076        reader.read()
 1077
 1078        return obj
 1079
 1080    @staticmethod
 1081    def read_many(reader):
 1082        # Do nothing if there aren't more tags:
 1083        objs = List()
 1084        if not reader.forward():
 1085            return objs
 1086
 1087        # Process the attributes:
 1088        objs.href = reader.get_attribute('href')
 1089
 1090        # Discard the start tag:
 1091        empty = reader.empty_element()
 1092        reader.read()
 1093        if empty:
 1094            return objs
 1095
 1096        # Process the inner elements:
 1097        while reader.forward():
 1098            objs.append(AuthorizedKeyReader.read_one(reader))
 1099
 1100        # Discard the end tag:
 1101        reader.read()
 1102
 1103        return objs
 1104
 1105
 1106class BackupReader(Reader):
 1107
 1108    def __init__(self):
 1109        super(BackupReader, self).__init__()
 1110
 1111    @staticmethod
 1112    def read_one(reader):
 1113        # Do nothing if there aren't more tags:
 1114        if not reader.forward():
 1115            return None
 1116
 1117        # Create the object:
 1118        obj = types.Backup()
 1119
 1120        # Process the attributes:
 1121        obj.href = reader.get_attribute('href')
 1122        value = reader.get_attribute('id')
 1123        if value is not None:
 1124            obj.id = value
 1125
 1126        # Discard the start tag:
 1127        empty = reader.empty_element()
 1128        reader.read()
 1129        if empty:
 1130            return obj
 1131
 1132        # Process the inner elements:
 1133        links = []
 1134        while reader.forward():
 1135            tag = reader.node_name()
 1136            if tag == 'comment':
 1137                obj.comment = Reader.read_string(reader)
 1138            elif tag == 'creation_date':
 1139                obj.creation_date = Reader.read_date(reader)
 1140            elif tag == 'description':
 1141                obj.description = Reader.read_string(reader)
 1142            elif tag == 'disks':
 1143                obj.disks = DiskReader.read_many(reader)
 1144            elif tag == 'from_checkpoint_id':
 1145                obj.from_checkpoint_id = Reader.read_string(reader)
 1146            elif tag == 'host':
 1147                obj.host = HostReader.read_one(reader)
 1148            elif tag == 'modification_date':
 1149                obj.modification_date = Reader.read_date(reader)
 1150            elif tag == 'name':
 1151                obj.name = Reader.read_string(reader)
 1152            elif tag == 'phase':
 1153                obj.phase = Reader.read_enum(types.BackupPhase, reader)
 1154            elif tag == 'snapshot':
 1155                obj.snapshot = SnapshotReader.read_one(reader)
 1156            elif tag == 'to_checkpoint_id':
 1157                obj.to_checkpoint_id = Reader.read_string(reader)
 1158            elif tag == 'vm':
 1159                obj.vm = VmReader.read_one(reader)
 1160            elif tag == 'link':
 1161                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 1162                reader.next_element()
 1163            else:
 1164                reader.next_element()
 1165        for link in links:
 1166            BackupReader._process_link(link, obj)
 1167
 1168        # Discard the end tag:
 1169        reader.read()
 1170
 1171        return obj
 1172
 1173    @staticmethod
 1174    def read_many(reader):
 1175        # Do nothing if there aren't more tags:
 1176        objs = List()
 1177        if not reader.forward():
 1178            return objs
 1179
 1180        # Process the attributes:
 1181        objs.href = reader.get_attribute('href')
 1182
 1183        # Discard the start tag:
 1184        empty = reader.empty_element()
 1185        reader.read()
 1186        if empty:
 1187            return objs
 1188
 1189        # Process the inner elements:
 1190        while reader.forward():
 1191            objs.append(BackupReader.read_one(reader))
 1192
 1193        # Discard the end tag:
 1194        reader.read()
 1195
 1196        return objs
 1197
 1198    @staticmethod
 1199    def _process_link(link, obj):
 1200        # Process the attributes:
 1201        rel = link[0]
 1202        href = link[1]
 1203        if href and rel:
 1204            if rel == "disks":
 1205                if obj.disks is not None:
 1206                    obj.disks.href = href
 1207                else:
 1208                    obj.disks = List(href)
 1209
 1210
 1211class BalanceReader(Reader):
 1212
 1213    def __init__(self):
 1214        super(BalanceReader, self).__init__()
 1215
 1216    @staticmethod
 1217    def read_one(reader):
 1218        # Do nothing if there aren't more tags:
 1219        if not reader.forward():
 1220            return None
 1221
 1222        # Create the object:
 1223        obj = types.Balance()
 1224
 1225        # Process the attributes:
 1226        obj.href = reader.get_attribute('href')
 1227        value = reader.get_attribute('id')
 1228        if value is not None:
 1229            obj.id = value
 1230
 1231        # Discard the start tag:
 1232        empty = reader.empty_element()
 1233        reader.read()
 1234        if empty:
 1235            return obj
 1236
 1237        # Process the inner elements:
 1238        links = []
 1239        while reader.forward():
 1240            tag = reader.node_name()
 1241            if tag == 'comment':
 1242                obj.comment = Reader.read_string(reader)
 1243            elif tag == 'description':
 1244                obj.description = Reader.read_string(reader)
 1245            elif tag == 'name':
 1246                obj.name = Reader.read_string(reader)
 1247            elif tag == 'scheduling_policy':
 1248                obj.scheduling_policy = SchedulingPolicyReader.read_one(reader)
 1249            elif tag == 'scheduling_policy_unit':
 1250                obj.scheduling_policy_unit = SchedulingPolicyUnitReader.read_one(reader)
 1251            else:
 1252                reader.next_element()
 1253        for link in links:
 1254            BalanceReader._process_link(link, obj)
 1255
 1256        # Discard the end tag:
 1257        reader.read()
 1258
 1259        return obj
 1260
 1261    @staticmethod
 1262    def read_many(reader):
 1263        # Do nothing if there aren't more tags:
 1264        objs = List()
 1265        if not reader.forward():
 1266            return objs
 1267
 1268        # Process the attributes:
 1269        objs.href = reader.get_attribute('href')
 1270
 1271        # Discard the start tag:
 1272        empty = reader.empty_element()
 1273        reader.read()
 1274        if empty:
 1275            return objs
 1276
 1277        # Process the inner elements:
 1278        while reader.forward():
 1279            objs.append(BalanceReader.read_one(reader))
 1280
 1281        # Discard the end tag:
 1282        reader.read()
 1283
 1284        return objs
 1285
 1286
 1287class BiosReader(Reader):
 1288
 1289    def __init__(self):
 1290        super(BiosReader, self).__init__()
 1291
 1292    @staticmethod
 1293    def read_one(reader):
 1294        # Do nothing if there aren't more tags:
 1295        if not reader.forward():
 1296            return None
 1297
 1298        # Create the object:
 1299        obj = types.Bios()
 1300
 1301        # Process the attributes:
 1302        obj.href = reader.get_attribute('href')
 1303
 1304        # Discard the start tag:
 1305        empty = reader.empty_element()
 1306        reader.read()
 1307        if empty:
 1308            return obj
 1309
 1310        # Process the inner elements:
 1311        links = []
 1312        while reader.forward():
 1313            tag = reader.node_name()
 1314            if tag == 'boot_menu':
 1315                obj.boot_menu = BootMenuReader.read_one(reader)
 1316            elif tag == 'type':
 1317                obj.type = Reader.read_enum(types.BiosType, reader)
 1318            else:
 1319                reader.next_element()
 1320        for link in links:
 1321            BiosReader._process_link(link, obj)
 1322
 1323        # Discard the end tag:
 1324        reader.read()
 1325
 1326        return obj
 1327
 1328    @staticmethod
 1329    def read_many(reader):
 1330        # Do nothing if there aren't more tags:
 1331        objs = List()
 1332        if not reader.forward():
 1333            return objs
 1334
 1335        # Process the attributes:
 1336        objs.href = reader.get_attribute('href')
 1337
 1338        # Discard the start tag:
 1339        empty = reader.empty_element()
 1340        reader.read()
 1341        if empty:
 1342            return objs
 1343
 1344        # Process the inner elements:
 1345        while reader.forward():
 1346            objs.append(BiosReader.read_one(reader))
 1347
 1348        # Discard the end tag:
 1349        reader.read()
 1350
 1351        return objs
 1352
 1353
 1354class BlockStatisticReader(Reader):
 1355
 1356    def __init__(self):
 1357        super(BlockStatisticReader, self).__init__()
 1358
 1359    @staticmethod
 1360    def read_one(reader):
 1361        # Do nothing if there aren't more tags:
 1362        if not reader.forward():
 1363            return None
 1364
 1365        # Create the object:
 1366        obj = types.BlockStatistic()
 1367
 1368        # Process the attributes:
 1369        obj.href = reader.get_attribute('href')
 1370
 1371        # Discard the start tag:
 1372        empty = reader.empty_element()
 1373        reader.read()
 1374        if empty:
 1375            return obj
 1376
 1377        # Process the inner elements:
 1378        links = []
 1379        while reader.forward():
 1380            tag = reader.node_name()
 1381            if tag == 'statistics':
 1382                obj.statistics = StatisticReader.read_many(reader)
 1383            else:
 1384                reader.next_element()
 1385        for link in links:
 1386            BlockStatisticReader._process_link(link, obj)
 1387
 1388        # Discard the end tag:
 1389        reader.read()
 1390
 1391        return obj
 1392
 1393    @staticmethod
 1394    def read_many(reader):
 1395        # Do nothing if there aren't more tags:
 1396        objs = List()
 1397        if not reader.forward():
 1398            return objs
 1399
 1400        # Process the attributes:
 1401        objs.href = reader.get_attribute('href')
 1402
 1403        # Discard the start tag:
 1404        empty = reader.empty_element()
 1405        reader.read()
 1406        if empty:
 1407            return objs
 1408
 1409        # Process the inner elements:
 1410        while reader.forward():
 1411            objs.append(BlockStatisticReader.read_one(reader))
 1412
 1413        # Discard the end tag:
 1414        reader.read()
 1415
 1416        return objs
 1417
 1418
 1419class BondingReader(Reader):
 1420
 1421    def __init__(self):
 1422        super(BondingReader, self).__init__()
 1423
 1424    @staticmethod
 1425    def read_one(reader):
 1426        # Do nothing if there aren't more tags:
 1427        if not reader.forward():
 1428            return None
 1429
 1430        # Create the object:
 1431        obj = types.Bonding()
 1432
 1433        # Process the attributes:
 1434        obj.href = reader.get_attribute('href')
 1435
 1436        # Discard the start tag:
 1437        empty = reader.empty_element()
 1438        reader.read()
 1439        if empty:
 1440            return obj
 1441
 1442        # Process the inner elements:
 1443        links = []
 1444        while reader.forward():
 1445            tag = reader.node_name()
 1446            if tag == 'active_slave':
 1447                obj.active_slave = HostNicReader.read_one(reader)
 1448            elif tag == 'ad_partner_mac':
 1449                obj.ad_partner_mac = MacReader.read_one(reader)
 1450            elif tag == 'options':
 1451                obj.options = OptionReader.read_many(reader)
 1452            elif tag == 'slaves':
 1453                obj.slaves = HostNicReader.read_many(reader)
 1454            else:
 1455                reader.next_element()
 1456        for link in links:
 1457            BondingReader._process_link(link, obj)
 1458
 1459        # Discard the end tag:
 1460        reader.read()
 1461
 1462        return obj
 1463
 1464    @staticmethod
 1465    def read_many(reader):
 1466        # Do nothing if there aren't more tags:
 1467        objs = List()
 1468        if not reader.forward():
 1469            return objs
 1470
 1471        # Process the attributes:
 1472        objs.href = reader.get_attribute('href')
 1473
 1474        # Discard the start tag:
 1475        empty = reader.empty_element()
 1476        reader.read()
 1477        if empty:
 1478            return objs
 1479
 1480        # Process the inner elements:
 1481        while reader.forward():
 1482            objs.append(BondingReader.read_one(reader))
 1483
 1484        # Discard the end tag:
 1485        reader.read()
 1486
 1487        return objs
 1488
 1489
 1490class BookmarkReader(Reader):
 1491
 1492    def __init__(self):
 1493        super(BookmarkReader, self).__init__()
 1494
 1495    @staticmethod
 1496    def read_one(reader):
 1497        # Do nothing if there aren't more tags:
 1498        if not reader.forward():
 1499            return None
 1500
 1501        # Create the object:
 1502        obj = types.Bookmark()
 1503
 1504        # Process the attributes:
 1505        obj.href = reader.get_attribute('href')
 1506        value = reader.get_attribute('id')
 1507        if value is not None:
 1508            obj.id = value
 1509
 1510        # Discard the start tag:
 1511        empty = reader.empty_element()
 1512        reader.read()
 1513        if empty:
 1514            return obj
 1515
 1516        # Process the inner elements:
 1517        links = []
 1518        while reader.forward():
 1519            tag = reader.node_name()
 1520            if tag == 'comment':
 1521                obj.comment = Reader.read_string(reader)
 1522            elif tag == 'description':
 1523                obj.description = Reader.read_string(reader)
 1524            elif tag == 'name':
 1525                obj.name = Reader.read_string(reader)
 1526            elif tag == 'value':
 1527                obj.value = Reader.read_string(reader)
 1528            else:
 1529                reader.next_element()
 1530        for link in links:
 1531            BookmarkReader._process_link(link, obj)
 1532
 1533        # Discard the end tag:
 1534        reader.read()
 1535
 1536        return obj
 1537
 1538    @staticmethod
 1539    def read_many(reader):
 1540        # Do nothing if there aren't more tags:
 1541        objs = List()
 1542        if not reader.forward():
 1543            return objs
 1544
 1545        # Process the attributes:
 1546        objs.href = reader.get_attribute('href')
 1547
 1548        # Discard the start tag:
 1549        empty = reader.empty_element()
 1550        reader.read()
 1551        if empty:
 1552            return objs
 1553
 1554        # Process the inner elements:
 1555        while reader.forward():
 1556            objs.append(BookmarkReader.read_one(reader))
 1557
 1558        # Discard the end tag:
 1559        reader.read()
 1560
 1561        return objs
 1562
 1563
 1564class BootReader(Reader):
 1565
 1566    def __init__(self):
 1567        super(BootReader, self).__init__()
 1568
 1569    @staticmethod
 1570    def read_one(reader):
 1571        # Do nothing if there aren't more tags:
 1572        if not reader.forward():
 1573            return None
 1574
 1575        # Create the object:
 1576        obj = types.Boot()
 1577
 1578        # Process the attributes:
 1579        obj.href = reader.get_attribute('href')
 1580
 1581        # Discard the start tag:
 1582        empty = reader.empty_element()
 1583        reader.read()
 1584        if empty:
 1585            return obj
 1586
 1587        # Process the inner elements:
 1588        links = []
 1589        while reader.forward():
 1590            tag = reader.node_name()
 1591            if tag == 'devices':
 1592                obj.devices = Reader.read_enums(types.BootDevice, reader)
 1593            else:
 1594                reader.next_element()
 1595        for link in links:
 1596            BootReader._process_link(link, obj)
 1597
 1598        # Discard the end tag:
 1599        reader.read()
 1600
 1601        return obj
 1602
 1603    @staticmethod
 1604    def read_many(reader):
 1605        # Do nothing if there aren't more tags:
 1606        objs = List()
 1607        if not reader.forward():
 1608            return objs
 1609
 1610        # Process the attributes:
 1611        objs.href = reader.get_attribute('href')
 1612
 1613        # Discard the start tag:
 1614        empty = reader.empty_element()
 1615        reader.read()
 1616        if empty:
 1617            return objs
 1618
 1619        # Process the inner elements:
 1620        while reader.forward():
 1621            objs.append(BootReader.read_one(reader))
 1622
 1623        # Discard the end tag:
 1624        reader.read()
 1625
 1626        return objs
 1627
 1628
 1629class BootMenuReader(Reader):
 1630
 1631    def __init__(self):
 1632        super(BootMenuReader, self).__init__()
 1633
 1634    @staticmethod
 1635    def read_one(reader):
 1636        # Do nothing if there aren't more tags:
 1637        if not reader.forward():
 1638            return None
 1639
 1640        # Create the object:
 1641        obj = types.BootMenu()
 1642
 1643        # Process the attributes:
 1644        obj.href = reader.get_attribute('href')
 1645
 1646        # Discard the start tag:
 1647        empty = reader.empty_element()
 1648        reader.read()
 1649        if empty:
 1650            return obj
 1651
 1652        # Process the inner elements:
 1653        links = []
 1654        while reader.forward():
 1655            tag = reader.node_name()
 1656            if tag == 'enabled':
 1657                obj.enabled = Reader.read_boolean(reader)
 1658            else:
 1659                reader.next_element()
 1660        for link in links:
 1661            BootMenuReader._process_link(link, obj)
 1662
 1663        # Discard the end tag:
 1664        reader.read()
 1665
 1666        return obj
 1667
 1668    @staticmethod
 1669    def read_many(reader):
 1670        # Do nothing if there aren't more tags:
 1671        objs = List()
 1672        if not reader.forward():
 1673            return objs
 1674
 1675        # Process the attributes:
 1676        objs.href = reader.get_attribute('href')
 1677
 1678        # Discard the start tag:
 1679        empty = reader.empty_element()
 1680        reader.read()
 1681        if empty:
 1682            return objs
 1683
 1684        # Process the inner elements:
 1685        while reader.forward():
 1686            objs.append(BootMenuReader.read_one(reader))
 1687
 1688        # Discard the end tag:
 1689        reader.read()
 1690
 1691        return objs
 1692
 1693
 1694class BrickProfileDetailReader(Reader):
 1695
 1696    def __init__(self):
 1697        super(BrickProfileDetailReader, self).__init__()
 1698
 1699    @staticmethod
 1700    def read_one(reader):
 1701        # Do nothing if there aren't more tags:
 1702        if not reader.forward():
 1703            return None
 1704
 1705        # Create the object:
 1706        obj = types.BrickProfileDetail()
 1707
 1708        # Process the attributes:
 1709        obj.href = reader.get_attribute('href')
 1710
 1711        # Discard the start tag:
 1712        empty = reader.empty_element()
 1713        reader.read()
 1714        if empty:
 1715            return obj
 1716
 1717        # Process the inner elements:
 1718        links = []
 1719        while reader.forward():
 1720            tag = reader.node_name()
 1721            if tag == 'brick':
 1722                obj.brick = GlusterBrickReader.read_one(reader)
 1723            elif tag == 'profile_details':
 1724                obj.profile_details = ProfileDetailReader.read_many(reader)
 1725            else:
 1726                reader.next_element()
 1727        for link in links:
 1728            BrickProfileDetailReader._process_link(link, obj)
 1729
 1730        # Discard the end tag:
 1731        reader.read()
 1732
 1733        return obj
 1734
 1735    @staticmethod
 1736    def read_many(reader):
 1737        # Do nothing if there aren't more tags:
 1738        objs = List()
 1739        if not reader.forward():
 1740            return objs
 1741
 1742        # Process the attributes:
 1743        objs.href = reader.get_attribute('href')
 1744
 1745        # Discard the start tag:
 1746        empty = reader.empty_element()
 1747        reader.read()
 1748        if empty:
 1749            return objs
 1750
 1751        # Process the inner elements:
 1752        while reader.forward():
 1753            objs.append(BrickProfileDetailReader.read_one(reader))
 1754
 1755        # Discard the end tag:
 1756        reader.read()
 1757
 1758        return objs
 1759
 1760
 1761class CdromReader(Reader):
 1762
 1763    def __init__(self):
 1764        super(CdromReader, self).__init__()
 1765
 1766    @staticmethod
 1767    def read_one(reader):
 1768        # Do nothing if there aren't more tags:
 1769        if not reader.forward():
 1770            return None
 1771
 1772        # Create the object:
 1773        obj = types.Cdrom()
 1774
 1775        # Process the attributes:
 1776        obj.href = reader.get_attribute('href')
 1777        value = reader.get_attribute('id')
 1778        if value is not None:
 1779            obj.id = value
 1780
 1781        # Discard the start tag:
 1782        empty = reader.empty_element()
 1783        reader.read()
 1784        if empty:
 1785            return obj
 1786
 1787        # Process the inner elements:
 1788        links = []
 1789        while reader.forward():
 1790            tag = reader.node_name()
 1791            if tag == 'comment':
 1792                obj.comment = Reader.read_string(reader)
 1793            elif tag == 'description':
 1794                obj.description = Reader.read_string(reader)
 1795            elif tag == 'file':
 1796                obj.file = FileReader.read_one(reader)
 1797            elif tag == 'instance_type':
 1798                obj.instance_type = InstanceTypeReader.read_one(reader)
 1799            elif tag == 'name':
 1800                obj.name = Reader.read_string(reader)
 1801            elif tag == 'template':
 1802                obj.template = TemplateReader.read_one(reader)
 1803            elif tag == 'vm':
 1804                obj.vm = VmReader.read_one(reader)
 1805            elif tag == 'vms':
 1806                obj.vms = VmReader.read_many(reader)
 1807            elif tag == 'link':
 1808                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 1809                reader.next_element()
 1810            else:
 1811                reader.next_element()
 1812        for link in links:
 1813            CdromReader._process_link(link, obj)
 1814
 1815        # Discard the end tag:
 1816        reader.read()
 1817
 1818        return obj
 1819
 1820    @staticmethod
 1821    def read_many(reader):
 1822        # Do nothing if there aren't more tags:
 1823        objs = List()
 1824        if not reader.forward():
 1825            return objs
 1826
 1827        # Process the attributes:
 1828        objs.href = reader.get_attribute('href')
 1829
 1830        # Discard the start tag:
 1831        empty = reader.empty_element()
 1832        reader.read()
 1833        if empty:
 1834            return objs
 1835
 1836        # Process the inner elements:
 1837        while reader.forward():
 1838            objs.append(CdromReader.read_one(reader))
 1839
 1840        # Discard the end tag:
 1841        reader.read()
 1842
 1843        return objs
 1844
 1845    @staticmethod
 1846    def _process_link(link, obj):
 1847        # Process the attributes:
 1848        rel = link[0]
 1849        href = link[1]
 1850        if href and rel:
 1851            if rel == "vms":
 1852                if obj.vms is not None:
 1853                    obj.vms.href = href
 1854                else:
 1855                    obj.vms = List(href)
 1856
 1857
 1858class CertificateReader(Reader):
 1859
 1860    def __init__(self):
 1861        super(CertificateReader, self).__init__()
 1862
 1863    @staticmethod
 1864    def read_one(reader):
 1865        # Do nothing if there aren't more tags:
 1866        if not reader.forward():
 1867            return None
 1868
 1869        # Create the object:
 1870        obj = types.Certificate()
 1871
 1872        # Process the attributes:
 1873        obj.href = reader.get_attribute('href')
 1874        value = reader.get_attribute('id')
 1875        if value is not None:
 1876            obj.id = value
 1877
 1878        # Discard the start tag:
 1879        empty = reader.empty_element()
 1880        reader.read()
 1881        if empty:
 1882            return obj
 1883
 1884        # Process the inner elements:
 1885        links = []
 1886        while reader.forward():
 1887            tag = reader.node_name()
 1888            if tag == 'comment':
 1889                obj.comment = Reader.read_string(reader)
 1890            elif tag == 'content':
 1891                obj.content = Reader.read_string(reader)
 1892            elif tag == 'description':
 1893                obj.description = Reader.read_string(reader)
 1894            elif tag == 'name':
 1895                obj.name = Reader.read_string(reader)
 1896            elif tag == 'organization':
 1897                obj.organization = Reader.read_string(reader)
 1898            elif tag == 'subject':
 1899                obj.subject = Reader.read_string(reader)
 1900            else:
 1901                reader.next_element()
 1902        for link in links:
 1903            CertificateReader._process_link(link, obj)
 1904
 1905        # Discard the end tag:
 1906        reader.read()
 1907
 1908        return obj
 1909
 1910    @staticmethod
 1911    def read_many(reader):
 1912        # Do nothing if there aren't more tags:
 1913        objs = List()
 1914        if not reader.forward():
 1915            return objs
 1916
 1917        # Process the attributes:
 1918        objs.href = reader.get_attribute('href')
 1919
 1920        # Discard the start tag:
 1921        empty = reader.empty_element()
 1922        reader.read()
 1923        if empty:
 1924            return objs
 1925
 1926        # Process the inner elements:
 1927        while reader.forward():
 1928            objs.append(CertificateReader.read_one(reader))
 1929
 1930        # Discard the end tag:
 1931        reader.read()
 1932
 1933        return objs
 1934
 1935
 1936class CheckpointReader(Reader):
 1937
 1938    def __init__(self):
 1939        super(CheckpointReader, self).__init__()
 1940
 1941    @staticmethod
 1942    def read_one(reader):
 1943        # Do nothing if there aren't more tags:
 1944        if not reader.forward():
 1945            return None
 1946
 1947        # Create the object:
 1948        obj = types.Checkpoint()
 1949
 1950        # Process the attributes:
 1951        obj.href = reader.get_attribute('href')
 1952        value = reader.get_attribute('id')
 1953        if value is not None:
 1954            obj.id = value
 1955
 1956        # Discard the start tag:
 1957        empty = reader.empty_element()
 1958        reader.read()
 1959        if empty:
 1960            return obj
 1961
 1962        # Process the inner elements:
 1963        links = []
 1964        while reader.forward():
 1965            tag = reader.node_name()
 1966            if tag == 'comment':
 1967                obj.comment = Reader.read_string(reader)
 1968            elif tag == 'creation_date':
 1969                obj.creation_date = Reader.read_date(reader)
 1970            elif tag == 'description':
 1971                obj.description = Reader.read_string(reader)
 1972            elif tag == 'disks':
 1973                obj.disks = DiskReader.read_many(reader)
 1974            elif tag == 'name':
 1975                obj.name = Reader.read_string(reader)
 1976            elif tag == 'parent_id':
 1977                obj.parent_id = Reader.read_string(reader)
 1978            elif tag == 'state':
 1979                obj.state = Reader.read_enum(types.CheckpointState, reader)
 1980            elif tag == 'vm':
 1981                obj.vm = VmReader.read_one(reader)
 1982            elif tag == 'link':
 1983                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 1984                reader.next_element()
 1985            else:
 1986                reader.next_element()
 1987        for link in links:
 1988            CheckpointReader._process_link(link, obj)
 1989
 1990        # Discard the end tag:
 1991        reader.read()
 1992
 1993        return obj
 1994
 1995    @staticmethod
 1996    def read_many(reader):
 1997        # Do nothing if there aren't more tags:
 1998        objs = List()
 1999        if not reader.forward():
 2000            return objs
 2001
 2002        # Process the attributes:
 2003        objs.href = reader.get_attribute('href')
 2004
 2005        # Discard the start tag:
 2006        empty = reader.empty_element()
 2007        reader.read()
 2008        if empty:
 2009            return objs
 2010
 2011        # Process the inner elements:
 2012        while reader.forward():
 2013            objs.append(CheckpointReader.read_one(reader))
 2014
 2015        # Discard the end tag:
 2016        reader.read()
 2017
 2018        return objs
 2019
 2020    @staticmethod
 2021    def _process_link(link, obj):
 2022        # Process the attributes:
 2023        rel = link[0]
 2024        href = link[1]
 2025        if href and rel:
 2026            if rel == "disks":
 2027                if obj.disks is not None:
 2028                    obj.disks.href = href
 2029                else:
 2030                    obj.disks = List(href)
 2031
 2032
 2033class CloudInitReader(Reader):
 2034
 2035    def __init__(self):
 2036        super(CloudInitReader, self).__init__()
 2037
 2038    @staticmethod
 2039    def read_one(reader):
 2040        # Do nothing if there aren't more tags:
 2041        if not reader.forward():
 2042            return None
 2043
 2044        # Create the object:
 2045        obj = types.CloudInit()
 2046
 2047        # Process the attributes:
 2048        obj.href = reader.get_attribute('href')
 2049
 2050        # Discard the start tag:
 2051        empty = reader.empty_element()
 2052        reader.read()
 2053        if empty:
 2054            return obj
 2055
 2056        # Process the inner elements:
 2057        links = []
 2058        while reader.forward():
 2059            tag = reader.node_name()
 2060            if tag == 'authorized_keys':
 2061                obj.authorized_keys = AuthorizedKeyReader.read_many(reader)
 2062            elif tag == 'files':
 2063                obj.files = FileReader.read_many(reader)
 2064            elif tag == 'host':
 2065                obj.host = HostReader.read_one(reader)
 2066            elif tag == 'network_configuration':
 2067                obj.network_configuration = NetworkConfigurationReader.read_one(reader)
 2068            elif tag == 'regenerate_ssh_keys':
 2069                obj.regenerate_ssh_keys = Reader.read_boolean(reader)
 2070            elif tag == 'timezone':
 2071                obj.timezone = Reader.read_string(reader)
 2072            elif tag == 'users':
 2073                obj.users = UserReader.read_many(reader)
 2074            else:
 2075                reader.next_element()
 2076        for link in links:
 2077            CloudInitReader._process_link(link, obj)
 2078
 2079        # Discard the end tag:
 2080        reader.read()
 2081
 2082        return obj
 2083
 2084    @staticmethod
 2085    def read_many(reader):
 2086        # Do nothing if there aren't more tags:
 2087        objs = List()
 2088        if not reader.forward():
 2089            return objs
 2090
 2091        # Process the attributes:
 2092        objs.href = reader.get_attribute('href')
 2093
 2094        # Discard the start tag:
 2095        empty = reader.empty_element()
 2096        reader.read()
 2097        if empty:
 2098            return objs
 2099
 2100        # Process the inner elements:
 2101        while reader.forward():
 2102            objs.append(CloudInitReader.read_one(reader))
 2103
 2104        # Discard the end tag:
 2105        reader.read()
 2106
 2107        return objs
 2108
 2109
 2110class ClusterReader(Reader):
 2111
 2112    def __init__(self):
 2113        super(ClusterReader, self).__init__()
 2114
 2115    @staticmethod
 2116    def read_one(reader):
 2117        # Do nothing if there aren't more tags:
 2118        if not reader.forward():
 2119            return None
 2120
 2121        # Create the object:
 2122        obj = types.Cluster()
 2123
 2124        # Process the attributes:
 2125        obj.href = reader.get_attribute('href')
 2126        value = reader.get_attribute('id')
 2127        if value is not None:
 2128            obj.id = value
 2129
 2130        # Discard the start tag:
 2131        empty = reader.empty_element()
 2132        reader.read()
 2133        if empty:
 2134            return obj
 2135
 2136        # Process the inner elements:
 2137        links = []
 2138        while reader.forward():
 2139            tag = reader.node_name()
 2140            if tag == 'affinity_groups':
 2141                obj.affinity_groups = AffinityGroupReader.read_many(reader)
 2142            elif tag == 'ballooning_enabled':
 2143                obj.ballooning_enabled = Reader.read_boolean(reader)
 2144            elif tag == 'bios_type':
 2145                obj.bios_type = Reader.read_enum(types.BiosType, reader)
 2146            elif tag == 'comment':
 2147                obj.comment = Reader.read_string(reader)
 2148            elif tag == 'cpu':
 2149                obj.cpu = CpuReader.read_one(reader)
 2150            elif tag == 'cpu_profiles':
 2151                obj.cpu_profiles = CpuProfileReader.read_many(reader)
 2152            elif tag == 'custom_scheduling_policy_properties':
 2153                obj.custom_scheduling_policy_properties = PropertyReader.read_many(reader)
 2154            elif tag == 'data_center':
 2155                obj.data_center = DataCenterReader.read_one(reader)
 2156            elif tag == 'description':
 2157                obj.description = Reader.read_string(reader)
 2158            elif tag == 'display':
 2159                obj.display = DisplayReader.read_one(reader)
 2160            elif tag == 'enabled_features':
 2161                obj.enabled_features = ClusterFeatureReader.read_many(reader)
 2162            elif tag == 'error_handling':
 2163                obj.error_handling = ErrorHandlingReader.read_one(reader)
 2164            elif tag == 'external_network_providers':
 2165                obj.external_network_providers = ExternalProviderReader.read_many(reader)
 2166            elif tag == 'fencing_policy':
 2167                obj.fencing_policy = FencingPolicyReader.read_one(reader)
 2168            elif tag == 'fips_mode':
 2169                obj.fips_mode = Reader.read_enum(types.FipsMode, reader)
 2170            elif tag == 'firewall_type':
 2171                obj.firewall_type = Reader.read_enum(types.FirewallType, reader)
 2172            elif tag == 'gluster_hooks':
 2173                obj.gluster_hooks = GlusterHookReader.read_many(reader)
 2174            elif tag == 'gluster_service':
 2175                obj.gluster_service = Reader.read_boolean(reader)
 2176            elif tag == 'gluster_tuned_profile':
 2177                obj.gluster_tuned_profile = Reader.read_string(reader)
 2178            elif tag == 'gluster_volumes':
 2179                obj.gluster_volumes = GlusterVolumeReader.read_many(reader)
 2180            elif tag == 'ha_reservation':
 2181                obj.ha_reservation = Reader.read_boolean(reader)
 2182            elif tag == 'ksm':
 2183                obj.ksm = KsmReader.read_one(reader)
 2184            elif tag == 'log_max_memory_used_threshold':
 2185                obj.log_max_memory_used_threshold = Reader.read_integer(reader)
 2186            elif tag == 'log_max_memory_used_threshold_type':
 2187                obj.log_max_memory_used_threshold_type = Reader.read_enum(types.LogMaxMemoryUsedThresholdType, reader)
 2188            elif tag == 'mac_pool':
 2189                obj.mac_pool = MacPoolReader.read_one(reader)
 2190            elif tag == 'maintenance_reason_required':
 2191                obj.maintenance_reason_required = Reader.read_boolean(reader)
 2192            elif tag == 'management_network':
 2193                obj.management_network = NetworkReader.read_one(reader)
 2194            elif tag == 'memory_policy':
 2195                obj.memory_policy = MemoryPolicyReader.read_one(reader)
 2196            elif tag == 'migration':
 2197                obj.migration = MigrationOptionsReader.read_one(reader)
 2198            elif tag == 'name':
 2199                obj.name = Reader.read_string(reader)
 2200            elif tag == 'network_filters':
 2201                obj.network_filters = NetworkFilterReader.read_many(reader)
 2202            elif tag == 'networks':
 2203                obj.networks = NetworkReader.read_many(reader)
 2204            elif tag == 'optional_reason':
 2205                obj.optional_reason = Reader.read_boolean(reader)
 2206            elif tag == 'permissions':
 2207                obj.permissions = PermissionReader.read_many(reader)
 2208            elif tag == 'required_rng_sources':
 2209                obj.required_rng_sources = Reader.read_enums(types.RngSource, reader)
 2210            elif tag == 'scheduling_policy':
 2211                obj.scheduling_policy = SchedulingPolicyReader.read_one(reader)
 2212            elif tag == 'serial_number':
 2213                obj.serial_number = SerialNumberReader.read_one(reader)
 2214            elif tag == 'supported_versions':
 2215                obj.supported_versions = VersionReader.read_many(reader)
 2216            elif tag == 'switch_type':
 2217                obj.switch_type = Reader.read_enum(types.SwitchType, reader)
 2218            elif tag == 'threads_as_cores':
 2219                obj.threads_as_cores = Reader.read_boolean(reader)
 2220            elif tag == 'trusted_service':
 2221                obj.trusted_service = Reader.read_boolean(reader)
 2222            elif tag == 'tunnel_migration':
 2223                obj.tunnel_migration = Reader.read_boolean(reader)
 2224            elif tag == 'upgrade_correlation_id':
 2225                obj.upgrade_correlation_id = Reader.read_string(reader)
 2226            elif tag == 'upgrade_in_progress':
 2227                obj.upgrade_in_progress = Reader.read_boolean(reader)
 2228            elif tag == 'upgrade_percent_complete':
 2229                obj.upgrade_percent_complete = Reader.read_integer(reader)
 2230            elif tag == 'version':
 2231                obj.version = VersionReader.read_one(reader)
 2232            elif tag == 'virt_service':
 2233                obj.virt_service = Reader.read_boolean(reader)
 2234            elif tag == 'vnc_encryption':
 2235                obj.vnc_encryption = Reader.read_boolean(reader)
 2236            elif tag == 'link':
 2237                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 2238                reader.next_element()
 2239            else:
 2240                reader.next_element()
 2241        for link in links:
 2242            ClusterReader._process_link(link, obj)
 2243
 2244        # Discard the end tag:
 2245        reader.read()
 2246
 2247        return obj
 2248
 2249    @staticmethod
 2250    def read_many(reader):
 2251        # Do nothing if there aren't more tags:
 2252        objs = List()
 2253        if not reader.forward():
 2254            return objs
 2255
 2256        # Process the attributes:
 2257        objs.href = reader.get_attribute('href')
 2258
 2259        # Discard the start tag:
 2260        empty = reader.empty_element()
 2261        reader.read()
 2262        if empty:
 2263            return objs
 2264
 2265        # Process the inner elements:
 2266        while reader.forward():
 2267            objs.append(ClusterReader.read_one(reader))
 2268
 2269        # Discard the end tag:
 2270        reader.read()
 2271
 2272        return objs
 2273
 2274    @staticmethod
 2275    def _process_link(link, obj):
 2276        # Process the attributes:
 2277        rel = link[0]
 2278        href = link[1]
 2279        if href and rel:
 2280            if rel == "affinitygroups":
 2281                if obj.affinity_groups is not None:
 2282                    obj.affinity_groups.href = href
 2283                else:
 2284                    obj.affinity_groups = List(href)
 2285            elif rel == "cpuprofiles":
 2286                if obj.cpu_profiles is not None:
 2287                    obj.cpu_profiles.href = href
 2288                else:
 2289                    obj.cpu_profiles = List(href)
 2290            elif rel == "enabledfeatures":
 2291                if obj.enabled_features is not None:
 2292                    obj.enabled_features.href = href
 2293                else:
 2294                    obj.enabled_features = List(href)
 2295            elif rel == "externalnetworkproviders":
 2296                if obj.external_network_providers is not None:
 2297                    obj.external_network_providers.href = href
 2298                else:
 2299                    obj.external_network_providers = List(href)
 2300            elif rel == "glusterhooks":
 2301                if obj.gluster_hooks is not None:
 2302                    obj.gluster_hooks.href = href
 2303                else:
 2304                    obj.gluster_hooks = List(href)
 2305            elif rel == "glustervolumes":
 2306                if obj.gluster_volumes is not None:
 2307                    obj.gluster_volumes.href = href
 2308                else:
 2309                    obj.gluster_volumes = List(href)
 2310            elif rel == "networkfilters":
 2311                if obj.network_filters is not None:
 2312                    obj.network_filters.href = href
 2313                else:
 2314                    obj.network_filters = List(href)
 2315            elif rel == "networks":
 2316                if obj.networks is not None:
 2317                    obj.networks.href = href
 2318                else:
 2319                    obj.networks = List(href)
 2320            elif rel == "permissions":
 2321                if obj.permissions is not None:
 2322                    obj.permissions.href = href
 2323                else:
 2324                    obj.permissions = List(href)
 2325
 2326
 2327class ClusterFeatureReader(Reader):
 2328
 2329    def __init__(self):
 2330        super(ClusterFeatureReader, self).__init__()
 2331
 2332    @staticmethod
 2333    def read_one(reader):
 2334        # Do nothing if there aren't more tags:
 2335        if not reader.forward():
 2336            return None
 2337
 2338        # Create the object:
 2339        obj = types.ClusterFeature()
 2340
 2341        # Process the attributes:
 2342        obj.href = reader.get_attribute('href')
 2343        value = reader.get_attribute('id')
 2344        if value is not None:
 2345            obj.id = value
 2346
 2347        # Discard the start tag:
 2348        empty = reader.empty_element()
 2349        reader.read()
 2350        if empty:
 2351            return obj
 2352
 2353        # Process the inner elements:
 2354        links = []
 2355        while reader.forward():
 2356            tag = reader.node_name()
 2357            if tag == 'cluster_level':
 2358                obj.cluster_level = ClusterLevelReader.read_one(reader)
 2359            elif tag == 'comment':
 2360                obj.comment = Reader.read_string(reader)
 2361            elif tag == 'description':
 2362                obj.description = Reader.read_string(reader)
 2363            elif tag == 'name':
 2364                obj.name = Reader.read_string(reader)
 2365            else:
 2366                reader.next_element()
 2367        for link in links:
 2368            ClusterFeatureReader._process_link(link, obj)
 2369
 2370        # Discard the end tag:
 2371        reader.read()
 2372
 2373        return obj
 2374
 2375    @staticmethod
 2376    def read_many(reader):
 2377        # Do nothing if there aren't more tags:
 2378        objs = List()
 2379        if not reader.forward():
 2380            return objs
 2381
 2382        # Process the attributes:
 2383        objs.href = reader.get_attribute('href')
 2384
 2385        # Discard the start tag:
 2386        empty = reader.empty_element()
 2387        reader.read()
 2388        if empty:
 2389            return objs
 2390
 2391        # Process the inner elements:
 2392        while reader.forward():
 2393            objs.append(ClusterFeatureReader.read_one(reader))
 2394
 2395        # Discard the end tag:
 2396        reader.read()
 2397
 2398        return objs
 2399
 2400
 2401class ClusterLevelReader(Reader):
 2402
 2403    def __init__(self):
 2404        super(ClusterLevelReader, self).__init__()
 2405
 2406    @staticmethod
 2407    def read_one(reader):
 2408        # Do nothing if there aren't more tags:
 2409        if not reader.forward():
 2410            return None
 2411
 2412        # Create the object:
 2413        obj = types.ClusterLevel()
 2414
 2415        # Process the attributes:
 2416        obj.href = reader.get_attribute('href')
 2417        value = reader.get_attribute('id')
 2418        if value is not None:
 2419            obj.id = value
 2420
 2421        # Discard the start tag:
 2422        empty = reader.empty_element()
 2423        reader.read()
 2424        if empty:
 2425            return obj
 2426
 2427        # Process the inner elements:
 2428        links = []
 2429        while reader.forward():
 2430            tag = reader.node_name()
 2431            if tag == 'cluster_features':
 2432                obj.cluster_features = ClusterFeatureReader.read_many(reader)
 2433            elif tag == 'comment':
 2434                obj.comment = Reader.read_string(reader)
 2435            elif tag == 'cpu_types':
 2436                obj.cpu_types = CpuTypeReader.read_many(reader)
 2437            elif tag == 'description':
 2438                obj.description = Reader.read_string(reader)
 2439            elif tag == 'name':
 2440                obj.name = Reader.read_string(reader)
 2441            elif tag == 'permits':
 2442                obj.permits = PermitReader.read_many(reader)
 2443            elif tag == 'link':
 2444                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 2445                reader.next_element()
 2446            else:
 2447                reader.next_element()
 2448        for link in links:
 2449            ClusterLevelReader._process_link(link, obj)
 2450
 2451        # Discard the end tag:
 2452        reader.read()
 2453
 2454        return obj
 2455
 2456    @staticmethod
 2457    def read_many(reader):
 2458        # Do nothing if there aren't more tags:
 2459        objs = List()
 2460        if not reader.forward():
 2461            return objs
 2462
 2463        # Process the attributes:
 2464        objs.href = reader.get_attribute('href')
 2465
 2466        # Discard the start tag:
 2467        empty = reader.empty_element()
 2468        reader.read()
 2469        if empty:
 2470            return objs
 2471
 2472        # Process the inner elements:
 2473        while reader.forward():
 2474            objs.append(ClusterLevelReader.read_one(reader))
 2475
 2476        # Discard the end tag:
 2477        reader.read()
 2478
 2479        return objs
 2480
 2481    @staticmethod
 2482    def _process_link(link, obj):
 2483        # Process the attributes:
 2484        rel = link[0]
 2485        href = link[1]
 2486        if href and rel:
 2487            if rel == "clusterfeatures":
 2488                if obj.cluster_features is not None:
 2489                    obj.cluster_features.href = href
 2490                else:
 2491                    obj.cluster_features = List(href)
 2492
 2493
 2494class ConfigurationReader(Reader):
 2495
 2496    def __init__(self):
 2497        super(ConfigurationReader, self).__init__()
 2498
 2499    @staticmethod
 2500    def read_one(reader):
 2501        # Do nothing if there aren't more tags:
 2502        if not reader.forward():
 2503            return None
 2504
 2505        # Create the object:
 2506        obj = types.Configuration()
 2507
 2508        # Process the attributes:
 2509        obj.href = reader.get_attribute('href')
 2510
 2511        # Discard the start tag:
 2512        empty = reader.empty_element()
 2513        reader.read()
 2514        if empty:
 2515            return obj
 2516
 2517        # Process the inner elements:
 2518        links = []
 2519        while reader.forward():
 2520            tag = reader.node_name()
 2521            if tag == 'data':
 2522                obj.data = Reader.read_string(reader)
 2523            elif tag == 'type':
 2524                obj.type = Reader.read_enum(types.ConfigurationType, reader)
 2525            else:
 2526                reader.next_element()
 2527        for link in links:
 2528            ConfigurationReader._process_link(link, obj)
 2529
 2530        # Discard the end tag:
 2531        reader.read()
 2532
 2533        return obj
 2534
 2535    @staticmethod
 2536    def read_many(reader):
 2537        # Do nothing if there aren't more tags:
 2538        objs = List()
 2539        if not reader.forward():
 2540            return objs
 2541
 2542        # Process the attributes:
 2543        objs.href = reader.get_attribute('href')
 2544
 2545        # Discard the start tag:
 2546        empty = reader.empty_element()
 2547        reader.read()
 2548        if empty:
 2549            return objs
 2550
 2551        # Process the inner elements:
 2552        while reader.forward():
 2553            objs.append(ConfigurationReader.read_one(reader))
 2554
 2555        # Discard the end tag:
 2556        reader.read()
 2557
 2558        return objs
 2559
 2560
 2561class ConsoleReader(Reader):
 2562
 2563    def __init__(self):
 2564        super(ConsoleReader, self).__init__()
 2565
 2566    @staticmethod
 2567    def read_one(reader):
 2568        # Do nothing if there aren't more tags:
 2569        if not reader.forward():
 2570            return None
 2571
 2572        # Create the object:
 2573        obj = types.Console()
 2574
 2575        # Process the attributes:
 2576        obj.href = reader.get_attribute('href')
 2577
 2578        # Discard the start tag:
 2579        empty = reader.empty_element()
 2580        reader.read()
 2581        if empty:
 2582            return obj
 2583
 2584        # Process the inner elements:
 2585        links = []
 2586        while reader.forward():
 2587            tag = reader.node_name()
 2588            if tag == 'enabled':
 2589                obj.enabled = Reader.read_boolean(reader)
 2590            else:
 2591                reader.next_element()
 2592        for link in links:
 2593            ConsoleReader._process_link(link, obj)
 2594
 2595        # Discard the end tag:
 2596        reader.read()
 2597
 2598        return obj
 2599
 2600    @staticmethod
 2601    def read_many(reader):
 2602        # Do nothing if there aren't more tags:
 2603        objs = List()
 2604        if not reader.forward():
 2605            return objs
 2606
 2607        # Process the attributes:
 2608        objs.href = reader.get_attribute('href')
 2609
 2610        # Discard the start tag:
 2611        empty = reader.empty_element()
 2612        reader.read()
 2613        if empty:
 2614            return objs
 2615
 2616        # Process the inner elements:
 2617        while reader.forward():
 2618            objs.append(ConsoleReader.read_one(reader))
 2619
 2620        # Discard the end tag:
 2621        reader.read()
 2622
 2623        return objs
 2624
 2625
 2626class CoreReader(Reader):
 2627
 2628    def __init__(self):
 2629        super(CoreReader, self).__init__()
 2630
 2631    @staticmethod
 2632    def read_one(reader):
 2633        # Do nothing if there aren't more tags:
 2634        if not reader.forward():
 2635            return None
 2636
 2637        # Create the object:
 2638        obj = types.Core()
 2639
 2640        # Process the attributes:
 2641        obj.href = reader.get_attribute('href')
 2642
 2643        # Discard the start tag:
 2644        empty = reader.empty_element()
 2645        reader.read()
 2646        if empty:
 2647            return obj
 2648
 2649        # Process the inner elements:
 2650        links = []
 2651        while reader.forward():
 2652            tag = reader.node_name()
 2653            if tag == 'index':
 2654                obj.index = Reader.read_integer(reader)
 2655            elif tag == 'socket':
 2656                obj.socket = Reader.read_integer(reader)
 2657            else:
 2658                reader.next_element()
 2659        for link in links:
 2660            CoreReader._process_link(link, obj)
 2661
 2662        # Discard the end tag:
 2663        reader.read()
 2664
 2665        return obj
 2666
 2667    @staticmethod
 2668    def read_many(reader):
 2669        # Do nothing if there aren't more tags:
 2670        objs = List()
 2671        if not reader.forward():
 2672            return objs
 2673
 2674        # Process the attributes:
 2675        objs.href = reader.get_attribute('href')
 2676
 2677        # Discard the start tag:
 2678        empty = reader.empty_element()
 2679        reader.read()
 2680        if empty:
 2681            return objs
 2682
 2683        # Process the inner elements:
 2684        while reader.forward():
 2685            objs.append(CoreReader.read_one(reader))
 2686
 2687        # Discard the end tag:
 2688        reader.read()
 2689
 2690        return objs
 2691
 2692
 2693class CpuReader(Reader):
 2694
 2695    def __init__(self):
 2696        super(CpuReader, self).__init__()
 2697
 2698    @staticmethod
 2699    def read_one(reader):
 2700        # Do nothing if there aren't more tags:
 2701        if not reader.forward():
 2702            return None
 2703
 2704        # Create the object:
 2705        obj = types.Cpu()
 2706
 2707        # Process the attributes:
 2708        obj.href = reader.get_attribute('href')
 2709
 2710        # Discard the start tag:
 2711        empty = reader.empty_element()
 2712        reader.read()
 2713        if empty:
 2714            return obj
 2715
 2716        # Process the inner elements:
 2717        links = []
 2718        while reader.forward():
 2719            tag = reader.node_name()
 2720            if tag == 'architecture':
 2721                obj.architecture = Reader.read_enum(types.Architecture, reader)
 2722            elif tag == 'cores':
 2723                obj.cores = CoreReader.read_many(reader)
 2724            elif tag == 'cpu_tune':
 2725                obj.cpu_tune = CpuTuneReader.read_one(reader)
 2726            elif tag == 'level':
 2727                obj.level = Reader.read_integer(reader)
 2728            elif tag == 'mode':
 2729                obj.mode = Reader.read_enum(types.CpuMode, reader)
 2730            elif tag == 'name':
 2731                obj.name = Reader.read_string(reader)
 2732            elif tag == 'speed':
 2733                obj.speed = Reader.read_decimal(reader)
 2734            elif tag == 'topology':
 2735                obj.topology = CpuTopologyReader.read_one(reader)
 2736            elif tag == 'type':
 2737                obj.type = Reader.read_string(reader)
 2738            else:
 2739                reader.next_element()
 2740        for link in links:
 2741            CpuReader._process_link(link, obj)
 2742
 2743        # Discard the end tag:
 2744        reader.read()
 2745
 2746        return obj
 2747
 2748    @staticmethod
 2749    def read_many(reader):
 2750        # Do nothing if there aren't more tags:
 2751        objs = List()
 2752        if not reader.forward():
 2753            return objs
 2754
 2755        # Process the attributes:
 2756        objs.href = reader.get_attribute('href')
 2757
 2758        # Discard the start tag:
 2759        empty = reader.empty_element()
 2760        reader.read()
 2761        if empty:
 2762            return objs
 2763
 2764        # Process the inner elements:
 2765        while reader.forward():
 2766            objs.append(CpuReader.read_one(reader))
 2767
 2768        # Discard the end tag:
 2769        reader.read()
 2770
 2771        return objs
 2772
 2773
 2774class CpuProfileReader(Reader):
 2775
 2776    def __init__(self):
 2777        super(CpuProfileReader, self).__init__()
 2778
 2779    @staticmethod
 2780    def read_one(reader):
 2781        # Do nothing if there aren't more tags:
 2782        if not reader.forward():
 2783            return None
 2784
 2785        # Create the object:
 2786        obj = types.CpuProfile()
 2787
 2788        # Process the attributes:
 2789        obj.href = reader.get_attribute('href')
 2790        value = reader.get_attribute('id')
 2791        if value is not None:
 2792            obj.id = value
 2793
 2794        # Discard the start tag:
 2795        empty = reader.empty_element()
 2796        reader.read()
 2797        if empty:
 2798            return obj
 2799
 2800        # Process the inner elements:
 2801        links = []
 2802        while reader.forward():
 2803            tag = reader.node_name()
 2804            if tag == 'cluster':
 2805                obj.cluster = ClusterReader.read_one(reader)
 2806            elif tag == 'comment':
 2807                obj.comment = Reader.read_string(reader)
 2808            elif tag == 'description':
 2809                obj.description = Reader.read_string(reader)
 2810            elif tag == 'name':
 2811                obj.name = Reader.read_string(reader)
 2812            elif tag == 'permissions':
 2813                obj.permissions = PermissionReader.read_many(reader)
 2814            elif tag == 'qos':
 2815                obj.qos = QosReader.read_one(reader)
 2816            elif tag == 'link':
 2817                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 2818                reader.next_element()
 2819            else:
 2820                reader.next_element()
 2821        for link in links:
 2822            CpuProfileReader._process_link(link, obj)
 2823
 2824        # Discard the end tag:
 2825        reader.read()
 2826
 2827        return obj
 2828
 2829    @staticmethod
 2830    def read_many(reader):
 2831        # Do nothing if there aren't more tags:
 2832        objs = List()
 2833        if not reader.forward():
 2834            return objs
 2835
 2836        # Process the attributes:
 2837        objs.href = reader.get_attribute('href')
 2838
 2839        # Discard the start tag:
 2840        empty = reader.empty_element()
 2841        reader.read()
 2842        if empty:
 2843            return objs
 2844
 2845        # Process the inner elements:
 2846        while reader.forward():
 2847            objs.append(CpuProfileReader.read_one(reader))
 2848
 2849        # Discard the end tag:
 2850        reader.read()
 2851
 2852        return objs
 2853
 2854    @staticmethod
 2855    def _process_link(link, obj):
 2856        # Process the attributes:
 2857        rel = link[0]
 2858        href = link[1]
 2859        if href and rel:
 2860            if rel == "permissions":
 2861                if obj.permissions is not None:
 2862                    obj.permissions.href = href
 2863                else:
 2864                    obj.permissions = List(href)
 2865
 2866
 2867class CpuTopologyReader(Reader):
 2868
 2869    def __init__(self):
 2870        super(CpuTopologyReader, self).__init__()
 2871
 2872    @staticmethod
 2873    def read_one(reader):
 2874        # Do nothing if there aren't more tags:
 2875        if not reader.forward():
 2876            return None
 2877
 2878        # Create the object:
 2879        obj = types.CpuTopology()
 2880
 2881        # Process the attributes:
 2882        obj.href = reader.get_attribute('href')
 2883
 2884        # Discard the start tag:
 2885        empty = reader.empty_element()
 2886        reader.read()
 2887        if empty:
 2888            return obj
 2889
 2890        # Process the inner elements:
 2891        links = []
 2892        while reader.forward():
 2893            tag = reader.node_name()
 2894            if tag == 'cores':
 2895                obj.cores = Reader.read_integer(reader)
 2896            elif tag == 'sockets':
 2897                obj.sockets = Reader.read_integer(reader)
 2898            elif tag == 'threads':
 2899                obj.threads = Reader.read_integer(reader)
 2900            else:
 2901                reader.next_element()
 2902        for link in links:
 2903            CpuTopologyReader._process_link(link, obj)
 2904
 2905        # Discard the end tag:
 2906        reader.read()
 2907
 2908        return obj
 2909
 2910    @staticmethod
 2911    def read_many(reader):
 2912        # Do nothing if there aren't more tags:
 2913        objs = List()
 2914        if not reader.forward():
 2915            return objs
 2916
 2917        # Process the attributes:
 2918        objs.href = reader.get_attribute('href')
 2919
 2920        # Discard the start tag:
 2921        empty = reader.empty_element()
 2922        reader.read()
 2923        if empty:
 2924            return objs
 2925
 2926        # Process the inner elements:
 2927        while reader.forward():
 2928            objs.append(CpuTopologyReader.read_one(reader))
 2929
 2930        # Discard the end tag:
 2931        reader.read()
 2932
 2933        return objs
 2934
 2935
 2936class CpuTuneReader(Reader):
 2937
 2938    def __init__(self):
 2939        super(CpuTuneReader, self).__init__()
 2940
 2941    @staticmethod
 2942    def read_one(reader):
 2943        # Do nothing if there aren't more tags:
 2944        if not reader.forward():
 2945            return None
 2946
 2947        # Create the object:
 2948        obj = types.CpuTune()
 2949
 2950        # Process the attributes:
 2951        obj.href = reader.get_attribute('href')
 2952
 2953        # Discard the start tag:
 2954        empty = reader.empty_element()
 2955        reader.read()
 2956        if empty:
 2957            return obj
 2958
 2959        # Process the inner elements:
 2960        links = []
 2961        while reader.forward():
 2962            tag = reader.node_name()
 2963            if tag == 'vcpu_pins':
 2964                obj.vcpu_pins = VcpuPinReader.read_many(reader)
 2965            else:
 2966                reader.next_element()
 2967        for link in links:
 2968            CpuTuneReader._process_link(link, obj)
 2969
 2970        # Discard the end tag:
 2971        reader.read()
 2972
 2973        return obj
 2974
 2975    @staticmethod
 2976    def read_many(reader):
 2977        # Do nothing if there aren't more tags:
 2978        objs = List()
 2979        if not reader.forward():
 2980            return objs
 2981
 2982        # Process the attributes:
 2983        objs.href = reader.get_attribute('href')
 2984
 2985        # Discard the start tag:
 2986        empty = reader.empty_element()
 2987        reader.read()
 2988        if empty:
 2989            return objs
 2990
 2991        # Process the inner elements:
 2992        while reader.forward():
 2993            objs.append(CpuTuneReader.read_one(reader))
 2994
 2995        # Discard the end tag:
 2996        reader.read()
 2997
 2998        return objs
 2999
 3000
 3001class CpuTypeReader(Reader):
 3002
 3003    def __init__(self):
 3004        super(CpuTypeReader, self).__init__()
 3005
 3006    @staticmethod
 3007    def read_one(reader):
 3008        # Do nothing if there aren't more tags:
 3009        if not reader.forward():
 3010            return None
 3011
 3012        # Create the object:
 3013        obj = types.CpuType()
 3014
 3015        # Process the attributes:
 3016        obj.href = reader.get_attribute('href')
 3017
 3018        # Discard the start tag:
 3019        empty = reader.empty_element()
 3020        reader.read()
 3021        if empty:
 3022            return obj
 3023
 3024        # Process the inner elements:
 3025        links = []
 3026        while reader.forward():
 3027            tag = reader.node_name()
 3028            if tag == 'architecture':
 3029                obj.architecture = Reader.read_enum(types.Architecture, reader)
 3030            elif tag == 'level':
 3031                obj.level = Reader.read_integer(reader)
 3032            elif tag == 'name':
 3033                obj.name = Reader.read_string(reader)
 3034            else:
 3035                reader.next_element()
 3036        for link in links:
 3037            CpuTypeReader._process_link(link, obj)
 3038
 3039        # Discard the end tag:
 3040        reader.read()
 3041
 3042        return obj
 3043
 3044    @staticmethod
 3045    def read_many(reader):
 3046        # Do nothing if there aren't more tags:
 3047        objs = List()
 3048        if not reader.forward():
 3049            return objs
 3050
 3051        # Process the attributes:
 3052        objs.href = reader.get_attribute('href')
 3053
 3054        # Discard the start tag:
 3055        empty = reader.empty_element()
 3056        reader.read()
 3057        if empty:
 3058            return objs
 3059
 3060        # Process the inner elements:
 3061        while reader.forward():
 3062            objs.append(CpuTypeReader.read_one(reader))
 3063
 3064        # Discard the end tag:
 3065        reader.read()
 3066
 3067        return objs
 3068
 3069
 3070class CustomPropertyReader(Reader):
 3071
 3072    def __init__(self):
 3073        super(CustomPropertyReader, self).__init__()
 3074
 3075    @staticmethod
 3076    def read_one(reader):
 3077        # Do nothing if there aren't more tags:
 3078        if not reader.forward():
 3079            return None
 3080
 3081        # Create the object:
 3082        obj = types.CustomProperty()
 3083
 3084        # Process the attributes:
 3085        obj.href = reader.get_attribute('href')
 3086
 3087        # Discard the start tag:
 3088        empty = reader.empty_element()
 3089        reader.read()
 3090        if empty:
 3091            return obj
 3092
 3093        # Process the inner elements:
 3094        links = []
 3095        while reader.forward():
 3096            tag = reader.node_name()
 3097            if tag == 'name':
 3098                obj.name = Reader.read_string(reader)
 3099            elif tag == 'regexp':
 3100                obj.regexp = Reader.read_string(reader)
 3101            elif tag == 'value':
 3102                obj.value = Reader.read_string(reader)
 3103            else:
 3104                reader.next_element()
 3105        for link in links:
 3106            CustomPropertyReader._process_link(link, obj)
 3107
 3108        # Discard the end tag:
 3109        reader.read()
 3110
 3111        return obj
 3112
 3113    @staticmethod
 3114    def read_many(reader):
 3115        # Do nothing if there aren't more tags:
 3116        objs = List()
 3117        if not reader.forward():
 3118            return objs
 3119
 3120        # Process the attributes:
 3121        objs.href = reader.get_attribute('href')
 3122
 3123        # Discard the start tag:
 3124        empty = reader.empty_element()
 3125        reader.read()
 3126        if empty:
 3127            return objs
 3128
 3129        # Process the inner elements:
 3130        while reader.forward():
 3131            objs.append(CustomPropertyReader.read_one(reader))
 3132
 3133        # Discard the end tag:
 3134        reader.read()
 3135
 3136        return objs
 3137
 3138
 3139class DataCenterReader(Reader):
 3140
 3141    def __init__(self):
 3142        super(DataCenterReader, self).__init__()
 3143
 3144    @staticmethod
 3145    def read_one(reader):
 3146        # Do nothing if there aren't more tags:
 3147        if not reader.forward():
 3148            return None
 3149
 3150        # Create the object:
 3151        obj = types.DataCenter()
 3152
 3153        # Process the attributes:
 3154        obj.href = reader.get_attribute('href')
 3155        value = reader.get_attribute('id')
 3156        if value is not None:
 3157            obj.id = value
 3158
 3159        # Discard the start tag:
 3160        empty = reader.empty_element()
 3161        reader.read()
 3162        if empty:
 3163            return obj
 3164
 3165        # Process the inner elements:
 3166        links = []
 3167        while reader.forward():
 3168            tag = reader.node_name()
 3169            if tag == 'clusters':
 3170                obj.clusters = ClusterReader.read_many(reader)
 3171            elif tag == 'comment':
 3172                obj.comment = Reader.read_string(reader)
 3173            elif tag == 'description':
 3174                obj.description = Reader.read_string(reader)
 3175            elif tag == 'iscsi_bonds':
 3176                obj.iscsi_bonds = IscsiBondReader.read_many(reader)
 3177            elif tag == 'local':
 3178                obj.local = Reader.read_boolean(reader)
 3179            elif tag == 'mac_pool':
 3180                obj.mac_pool = MacPoolReader.read_one(reader)
 3181            elif tag == 'name':
 3182                obj.name = Reader.read_string(reader)
 3183            elif tag == 'networks':
 3184                obj.networks = NetworkReader.read_many(reader)
 3185            elif tag == 'permissions':
 3186                obj.permissions = PermissionReader.read_many(reader)
 3187            elif tag == 'qoss':
 3188                obj.qoss = QosReader.read_many(reader)
 3189            elif tag == 'quota_mode':
 3190                obj.quota_mode = Reader.read_enum(types.QuotaModeType, reader)
 3191            elif tag == 'quotas':
 3192                obj.quotas = QuotaReader.read_many(reader)
 3193            elif tag == 'status':
 3194                obj.status = Reader.read_enum(types.DataCenterStatus, reader)
 3195            elif tag == 'storage_domains':
 3196                obj.storage_domains = StorageDomainReader.read_many(reader)
 3197            elif tag == 'storage_format':
 3198                obj.storage_format = Reader.read_enum(types.StorageFormat, reader)
 3199            elif tag == 'supported_versions':
 3200                obj.supported_versions = VersionReader.read_many(reader)
 3201            elif tag == 'version':
 3202                obj.version = VersionReader.read_one(reader)
 3203            elif tag == 'link':
 3204                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 3205                reader.next_element()
 3206            else:
 3207                reader.next_element()
 3208        for link in links:
 3209            DataCenterReader._process_link(link, obj)
 3210
 3211        # Discard the end tag:
 3212        reader.read()
 3213
 3214        return obj
 3215
 3216    @staticmethod
 3217    def read_many(reader):
 3218        # Do nothing if there aren't more tags:
 3219        objs = List()
 3220        if not reader.forward():
 3221            return objs
 3222
 3223        # Process the attributes:
 3224        objs.href = reader.get_attribute('href')
 3225
 3226        # Discard the start tag:
 3227        empty = reader.empty_element()
 3228        reader.read()
 3229        if empty:
 3230            return objs
 3231
 3232        # Process the inner elements:
 3233        while reader.forward():
 3234            objs.append(DataCenterReader.read_one(reader))
 3235
 3236        # Discard the end tag:
 3237        reader.read()
 3238
 3239        return objs
 3240
 3241    @staticmethod
 3242    def _process_link(link, obj):
 3243        # Process the attributes:
 3244        rel = link[0]
 3245        href = link[1]
 3246        if href and rel:
 3247            if rel == "clusters":
 3248                if obj.clusters is not None:
 3249                    obj.clusters.href = href
 3250                else:
 3251                    obj.clusters = List(href)
 3252            elif rel == "iscsibonds":
 3253                if obj.iscsi_bonds is not None:
 3254                    obj.iscsi_bonds.href = href
 3255                else:
 3256                    obj.iscsi_bonds = List(href)
 3257            elif rel == "networks":
 3258                if obj.networks is not None:
 3259                    obj.networks.href = href
 3260                else:
 3261                    obj.networks = List(href)
 3262            elif rel == "permissions":
 3263                if obj.permissions is not None:
 3264                    obj.permissions.href = href
 3265                else:
 3266                    obj.permissions = List(href)
 3267            elif rel == "qoss":
 3268                if obj.qoss is not None:
 3269                    obj.qoss.href = href
 3270                else:
 3271                    obj.qoss = List(href)
 3272            elif rel == "quotas":
 3273                if obj.quotas is not None:
 3274                    obj.quotas.href = href
 3275                else:
 3276                    obj.quotas = List(href)
 3277            elif rel == "storagedomains":
 3278                if obj.storage_domains is not None:
 3279                    obj.storage_domains.href = href
 3280                else:
 3281                    obj.storage_domains = List(href)
 3282
 3283
 3284class DeviceReader(Reader):
 3285
 3286    def __init__(self):
 3287        super(DeviceReader, self).__init__()
 3288
 3289    @staticmethod
 3290    def read_one(reader):
 3291        # Do nothing if there aren't more tags:
 3292        if not reader.forward():
 3293            return None
 3294
 3295        # Create the object:
 3296        obj = types.Device()
 3297
 3298        # Process the attributes:
 3299        obj.href = reader.get_attribute('href')
 3300        value = reader.get_attribute('id')
 3301        if value is not None:
 3302            obj.id = value
 3303
 3304        # Discard the start tag:
 3305        empty = reader.empty_element()
 3306        reader.read()
 3307        if empty:
 3308            return obj
 3309
 3310        # Process the inner elements:
 3311        links = []
 3312        while reader.forward():
 3313            tag = reader.node_name()
 3314            if tag == 'comment':
 3315                obj.comment = Reader.read_string(reader)
 3316            elif tag == 'description':
 3317                obj.description = Reader.read_string(reader)
 3318            elif tag == 'instance_type':
 3319                obj.instance_type = InstanceTypeReader.read_one(reader)
 3320            elif tag == 'name':
 3321                obj.name = Reader.read_string(reader)
 3322            elif tag == 'template':
 3323                obj.template = TemplateReader.read_one(reader)
 3324            elif tag == 'vm':
 3325                obj.vm = VmReader.read_one(reader)
 3326            elif tag == 'vms':
 3327                obj.vms = VmReader.read_many(reader)
 3328            elif tag == 'link':
 3329                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 3330                reader.next_element()
 3331            else:
 3332                reader.next_element()
 3333        for link in links:
 3334            DeviceReader._process_link(link, obj)
 3335
 3336        # Discard the end tag:
 3337        reader.read()
 3338
 3339        return obj
 3340
 3341    @staticmethod
 3342    def read_many(reader):
 3343        # Do nothing if there aren't more tags:
 3344        objs = List()
 3345        if not reader.forward():
 3346            return objs
 3347
 3348        # Process the attributes:
 3349        objs.href = reader.get_attribute('href')
 3350
 3351        # Discard the start tag:
 3352        empty = reader.empty_element()
 3353        reader.read()
 3354        if empty:
 3355            return objs
 3356
 3357        # Process the inner elements:
 3358        while reader.forward():
 3359            objs.append(DeviceReader.read_one(reader))
 3360
 3361        # Discard the end tag:
 3362        reader.read()
 3363
 3364        return objs
 3365
 3366    @staticmethod
 3367    def _process_link(link, obj):
 3368        # Process the attributes:
 3369        rel = link[0]
 3370        href = link[1]
 3371        if href and rel:
 3372            if rel == "vms":
 3373                if obj.vms is not None:
 3374                    obj.vms.href = href
 3375                else:
 3376                    obj.vms = List(href)
 3377
 3378
 3379class DiskReader(Reader):
 3380
 3381    def __init__(self):
 3382        super(DiskReader, self).__init__()
 3383
 3384    @staticmethod
 3385    def read_one(reader):
 3386        # Do nothing if there aren't more tags:
 3387        if not reader.forward():
 3388            return None
 3389
 3390        # Create the object:
 3391        obj = types.Disk()
 3392
 3393        # Process the attributes:
 3394        obj.href = reader.get_attribute('href')
 3395        value = reader.get_attribute('id')
 3396        if value is not None:
 3397            obj.id = value
 3398
 3399        # Discard the start tag:
 3400        empty = reader.empty_element()
 3401        reader.read()
 3402        if empty:
 3403            return obj
 3404
 3405        # Process the inner elements:
 3406        links = []
 3407        while reader.forward():
 3408            tag = reader.node_name()
 3409            if tag == 'active':
 3410                obj.active = Reader.read_boolean(reader)
 3411            elif tag == 'actual_size':
 3412                obj.actual_size = Reader.read_integer(reader)
 3413            elif tag == 'alias':
 3414                obj.alias = Reader.read_string(reader)
 3415            elif tag == 'backup':
 3416                obj.backup = Reader.read_enum(types.DiskBackup, reader)
 3417            elif tag == 'backup_mode':
 3418                obj.backup_mode = Reader.read_enum(types.DiskBackupMode, reader)
 3419            elif tag == 'bootable':
 3420                obj.bootable = Reader.read_boolean(reader)
 3421            elif tag == 'comment':
 3422                obj.comment = Reader.read_string(reader)
 3423            elif tag == 'content_type':
 3424                obj.content_type = Reader.read_enum(types.DiskContentType, reader)
 3425            elif tag == 'description':
 3426                obj.description = Reader.read_string(reader)
 3427            elif tag == 'disk_profile':
 3428                obj.disk_profile = DiskProfileReader.read_one(reader)
 3429            elif tag == 'disk_snapshots':
 3430                obj.disk_snapshots = DiskSnapshotReader.read_many(reader)
 3431            elif tag == 'external_disk':
 3432                obj.external_disk = Reader.read_string(reader)
 3433            elif tag == 'format':
 3434                obj.format = Reader.read_enum(types.DiskFormat, reader)
 3435            elif tag == 'image_id':
 3436                obj.image_id = Reader.read_string(reader)
 3437            elif tag == 'initial_size':
 3438                obj.initial_size = Reader.read_integer(reader)
 3439            elif tag == 'instance_type':
 3440                obj.instance_type = InstanceTypeReader.read_one(reader)
 3441            elif tag == 'interface':
 3442                obj.interface = Reader.read_enum(types.DiskInterface, reader)
 3443            elif tag == 'logical_name':
 3444                obj.logical_name = Reader.read_string(reader)
 3445            elif tag == 'lun_storage':
 3446                obj.lun_storage = HostStorageReader.read_one(reader)
 3447            elif tag == 'name':
 3448                obj.name = Reader.read_string(reader)
 3449            elif tag == 'openstack_volume_type':
 3450                obj.openstack_volume_type = OpenStackVolumeTypeReader.read_one(reader)
 3451            elif tag == 'permissions':
 3452                obj.permissions = PermissionReader.read_many(reader)
 3453            elif tag == 'propagate_errors':
 3454                obj.propagate_errors = Reader.read_boolean(reader)
 3455            elif tag == 'provisioned_size':
 3456                obj.provisioned_size = Reader.read_integer(reader)
 3457            elif tag == 'qcow_version':
 3458                obj.qcow_version = Reader.read_enum(types.QcowVersion, reader)
 3459            elif tag == 'quota':
 3460                obj.quota = QuotaReader.read_one(reader)
 3461            elif tag == 'read_only':
 3462                obj.read_only = Reader.read_boolean(reader)
 3463            elif tag == 'sgio':
 3464                obj.sgio = Reader.read_enum(types.ScsiGenericIO, reader)
 3465            elif tag == 'shareable':
 3466                obj.shareable = Reader.read_boolean(reader)
 3467            elif tag == 'snapshot':
 3468                obj.snapshot = SnapshotReader.read_one(reader)
 3469            elif tag == 'sparse':
 3470                obj.sparse = Reader.read_boolean(reader)
 3471            elif tag == 'statistics':
 3472                obj.statistics = StatisticReader.read_many(reader)
 3473            elif tag == 'status':
 3474                obj.status = Reader.read_enum(types.DiskStatus, reader)
 3475            elif tag == 'storage_domain':
 3476                obj.storage_domain = StorageDomainReader.read_one(reader)
 3477            elif tag == 'storage_domains':
 3478                obj.storage_domains = StorageDomainReader.read_many(reader)
 3479            elif tag == 'storage_type':
 3480                obj.storage_type = Reader.read_enum(types.DiskStorageType, reader)
 3481            elif tag == 'template':
 3482                obj.template = TemplateReader.read_one(reader)
 3483            elif tag == 'total_size':
 3484                obj.total_size = Reader.read_integer(reader)
 3485            elif tag == 'uses_scsi_reservation':
 3486                obj.uses_scsi_reservation = Reader.read_boolean(reader)
 3487            elif tag == 'vm':
 3488                obj.vm = VmReader.read_one(reader)
 3489            elif tag == 'vms':
 3490                obj.vms = VmReader.read_many(reader)
 3491            elif tag == 'wipe_after_delete':
 3492                obj.wipe_after_delete = Reader.read_boolean(reader)
 3493            elif tag == 'link':
 3494                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 3495                reader.next_element()
 3496            else:
 3497                reader.next_element()
 3498        for link in links:
 3499            DiskReader._process_link(link, obj)
 3500
 3501        # Discard the end tag:
 3502        reader.read()
 3503
 3504        return obj
 3505
 3506    @staticmethod
 3507    def read_many(reader):
 3508        # Do nothing if there aren't more tags:
 3509        objs = List()
 3510        if not reader.forward():
 3511            return objs
 3512
 3513        # Process the attributes:
 3514        objs.href = reader.get_attribute('href')
 3515
 3516        # Discard the start tag:
 3517        empty = reader.empty_element()
 3518        reader.read()
 3519        if empty:
 3520            return objs
 3521
 3522        # Process the inner elements:
 3523        while reader.forward():
 3524            objs.append(DiskReader.read_one(reader))
 3525
 3526        # Discard the end tag:
 3527        reader.read()
 3528
 3529        return objs
 3530
 3531    @staticmethod
 3532    def _process_link(link, obj):
 3533        # Process the attributes:
 3534        rel = link[0]
 3535        href = link[1]
 3536        if href and rel:
 3537            if rel == "disksnapshots":
 3538                if obj.disk_snapshots is not None:
 3539                    obj.disk_snapshots.href = href
 3540                else:
 3541                    obj.disk_snapshots = List(href)
 3542            elif rel == "permissions":
 3543                if obj.permissions is not None:
 3544                    obj.permissions.href = href
 3545                else:
 3546                    obj.permissions = List(href)
 3547            elif rel == "statistics":
 3548                if obj.statistics is not None:
 3549                    obj.statistics.href = href
 3550                else:
 3551                    obj.statistics = List(href)
 3552            elif rel == "storagedomains":
 3553                if obj.storage_domains is not None:
 3554                    obj.storage_domains.href = href
 3555                else:
 3556                    obj.storage_domains = List(href)
 3557            elif rel == "vms":
 3558                if obj.vms is not None:
 3559                    obj.vms.href = href
 3560                else:
 3561                    obj.vms = List(href)
 3562
 3563
 3564class DiskAttachmentReader(Reader):
 3565
 3566    def __init__(self):
 3567        super(DiskAttachmentReader, self).__init__()
 3568
 3569    @staticmethod
 3570    def read_one(reader):
 3571        # Do nothing if there aren't more tags:
 3572        if not reader.forward():
 3573            return None
 3574
 3575        # Create the object:
 3576        obj = types.DiskAttachment()
 3577
 3578        # Process the attributes:
 3579        obj.href = reader.get_attribute('href')
 3580        value = reader.get_attribute('id')
 3581        if value is not None:
 3582            obj.id = value
 3583
 3584        # Discard the start tag:
 3585        empty = reader.empty_element()
 3586        reader.read()
 3587        if empty:
 3588            return obj
 3589
 3590        # Process the inner elements:
 3591        links = []
 3592        while reader.forward():
 3593            tag = reader.node_name()
 3594            if tag == 'active':
 3595                obj.active = Reader.read_boolean(reader)
 3596            elif tag == 'bootable':
 3597                obj.bootable = Reader.read_boolean(reader)
 3598            elif tag == 'comment':
 3599                obj.comment = Reader.read_string(reader)
 3600            elif tag == 'description':
 3601                obj.description = Reader.read_string(reader)
 3602            elif tag == 'disk':
 3603                obj.disk = DiskReader.read_one(reader)
 3604            elif tag == 'interface':
 3605                obj.interface = Reader.read_enum(types.DiskInterface, reader)
 3606            elif tag == 'logical_name':
 3607                obj.logical_name = Reader.read_string(reader)
 3608            elif tag == 'name':
 3609                obj.name = Reader.read_string(reader)
 3610            elif tag == 'pass_discard':
 3611                obj.pass_discard = Reader.read_boolean(reader)
 3612            elif tag == 'read_only':
 3613                obj.read_only = Reader.read_boolean(reader)
 3614            elif tag == 'template':
 3615                obj.template = TemplateReader.read_one(reader)
 3616            elif tag == 'uses_scsi_reservation':
 3617                obj.uses_scsi_reservation = Reader.read_boolean(reader)
 3618            elif tag == 'vm':
 3619                obj.vm = VmReader.read_one(reader)
 3620            else:
 3621                reader.next_element()
 3622        for link in links:
 3623            DiskAttachmentReader._process_link(link, obj)
 3624
 3625        # Discard the end tag:
 3626        reader.read()
 3627
 3628        return obj
 3629
 3630    @staticmethod
 3631    def read_many(reader):
 3632        # Do nothing if there aren't more tags:
 3633        objs = List()
 3634        if not reader.forward():
 3635            return objs
 3636
 3637        # Process the attributes:
 3638        objs.href = reader.get_attribute('href')
 3639
 3640        # Discard the start tag:
 3641        empty = reader.empty_element()
 3642        reader.read()
 3643        if empty:
 3644            return objs
 3645
 3646        # Process the inner elements:
 3647        while reader.forward():
 3648            objs.append(DiskAttachmentReader.read_one(reader))
 3649
 3650        # Discard the end tag:
 3651        reader.read()
 3652
 3653        return objs
 3654
 3655
 3656class DiskProfileReader(Reader):
 3657
 3658    def __init__(self):
 3659        super(DiskProfileReader, self).__init__()
 3660
 3661    @staticmethod
 3662    def read_one(reader):
 3663        # Do nothing if there aren't more tags:
 3664        if not reader.forward():
 3665            return None
 3666
 3667        # Create the object:
 3668        obj = types.DiskProfile()
 3669
 3670        # Process the attributes:
 3671        obj.href = reader.get_attribute('href')
 3672        value = reader.get_attribute('id')
 3673        if value is not None:
 3674            obj.id = value
 3675
 3676        # Discard the start tag:
 3677        empty = reader.empty_element()
 3678        reader.read()
 3679        if empty:
 3680            return obj
 3681
 3682        # Process the inner elements:
 3683        links = []
 3684        while reader.forward():
 3685            tag = reader.node_name()
 3686            if tag == 'comment':
 3687                obj.comment = Reader.read_string(reader)
 3688            elif tag == 'description':
 3689                obj.description = Reader.read_string(reader)
 3690            elif tag == 'name':
 3691                obj.name = Reader.read_string(reader)
 3692            elif tag == 'permissions':
 3693                obj.permissions = PermissionReader.read_many(reader)
 3694            elif tag == 'qos':
 3695                obj.qos = QosReader.read_one(reader)
 3696            elif tag == 'storage_domain':
 3697                obj.storage_domain = StorageDomainReader.read_one(reader)
 3698            elif tag == 'link':
 3699                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 3700                reader.next_element()
 3701            else:
 3702                reader.next_element()
 3703        for link in links:
 3704            DiskProfileReader._process_link(link, obj)
 3705
 3706        # Discard the end tag:
 3707        reader.read()
 3708
 3709        return obj
 3710
 3711    @staticmethod
 3712    def read_many(reader):
 3713        # Do nothing if there aren't more tags:
 3714        objs = List()
 3715        if not reader.forward():
 3716            return objs
 3717
 3718        # Process the attributes:
 3719        objs.href = reader.get_attribute('href')
 3720
 3721        # Discard the start tag:
 3722        empty = reader.empty_element()
 3723        reader.read()
 3724        if empty:
 3725            return objs
 3726
 3727        # Process the inner elements:
 3728        while reader.forward():
 3729            objs.append(DiskProfileReader.read_one(reader))
 3730
 3731        # Discard the end tag:
 3732        reader.read()
 3733
 3734        return objs
 3735
 3736    @staticmethod
 3737    def _process_link(link, obj):
 3738        # Process the attributes:
 3739        rel = link[0]
 3740        href = link[1]
 3741        if href and rel:
 3742            if rel == "permissions":
 3743                if obj.permissions is not None:
 3744                    obj.permissions.href = href
 3745                else:
 3746                    obj.permissions = List(href)
 3747
 3748
 3749class DiskSnapshotReader(Reader):
 3750
 3751    def __init__(self):
 3752        super(DiskSnapshotReader, self).__init__()
 3753
 3754    @staticmethod
 3755    def read_one(reader):
 3756        # Do nothing if there aren't more tags:
 3757        if not reader.forward():
 3758            return None
 3759
 3760        # Create the object:
 3761        obj = types.DiskSnapshot()
 3762
 3763        # Process the attributes:
 3764        obj.href = reader.get_attribute('href')
 3765        value = reader.get_attribute('id')
 3766        if value is not None:
 3767            obj.id = value
 3768
 3769        # Discard the start tag:
 3770        empty = reader.empty_element()
 3771        reader.read()
 3772        if empty:
 3773            return obj
 3774
 3775        # Process the inner elements:
 3776        links = []
 3777        while reader.forward():
 3778            tag = reader.node_name()
 3779            if tag == 'active':
 3780                obj.active = Reader.read_boolean(reader)
 3781            elif tag == 'actual_size':
 3782                obj.actual_size = Reader.read_integer(reader)
 3783            elif tag == 'alias':
 3784                obj.alias = Reader.read_string(reader)
 3785            elif tag == 'backup':
 3786                obj.backup = Reader.read_enum(types.DiskBackup, reader)
 3787            elif tag == 'backup_mode':
 3788                obj.backup_mode = Reader.read_enum(types.DiskBackupMode, reader)
 3789            elif tag == 'bootable':
 3790                obj.bootable = Reader.read_boolean(reader)
 3791            elif tag == 'comment':
 3792                obj.comment = Reader.read_string(reader)
 3793            elif tag == 'content_type':
 3794                obj.content_type = Reader.read_enum(types.DiskContentType, reader)
 3795            elif tag == 'description':
 3796                obj.description = Reader.read_string(reader)
 3797            elif tag == 'disk':
 3798                obj.disk = DiskReader.read_one(reader)
 3799            elif tag == 'disk_profile':
 3800                obj.disk_profile = DiskProfileReader.read_one(reader)
 3801            elif tag == 'disk_snapshots':
 3802                obj.disk_snapshots = DiskSnapshotReader.read_many(reader)
 3803            elif tag == 'external_disk':
 3804                obj.external_disk = Reader.read_string(reader)
 3805            elif tag == 'format':
 3806                obj.format = Reader.read_enum(types.DiskFormat, reader)
 3807            elif tag == 'image_id':
 3808                obj.image_id = Reader.read_string(reader)
 3809            elif tag == 'initial_size':
 3810                obj.initial_size = Reader.read_integer(reader)
 3811            elif tag == 'instance_type':
 3812                obj.instance_type = InstanceTypeReader.read_one(reader)
 3813            elif tag == 'interface':
 3814                obj.interface = Reader.read_enum(types.DiskInterface, reader)
 3815            elif tag == 'logical_name':
 3816                obj.logical_name = Reader.read_string(reader)
 3817            elif tag == 'lun_storage':
 3818                obj.lun_storage = HostStorageReader.read_one(reader)
 3819            elif tag == 'name':
 3820                obj.name = Reader.read_string(reader)
 3821            elif tag == 'openstack_volume_type':
 3822                obj.openstack_volume_type = OpenStackVolumeTypeReader.read_one(reader)
 3823            elif tag == 'parent':
 3824                obj.parent = DiskSnapshotReader.read_one(reader)
 3825            elif tag == 'permissions':
 3826                obj.permissions = PermissionReader.read_many(reader)
 3827            elif tag == 'propagate_errors':
 3828                obj.propagate_errors = Reader.read_boolean(reader)
 3829            elif tag == 'provisioned_size':
 3830                obj.provisioned_size = Reader.read_integer(reader)
 3831            elif tag == 'qcow_version':
 3832                obj.qcow_version = Reader.read_enum(types.QcowVersion, reader)
 3833            elif tag == 'quota':
 3834                obj.quota = QuotaReader.read_one(reader)
 3835            elif tag == 'read_only':
 3836                obj.read_only = Reader.read_boolean(reader)
 3837            elif tag == 'sgio':
 3838                obj.sgio = Reader.read_enum(types.ScsiGenericIO, reader)
 3839            elif tag == 'shareable':
 3840                obj.shareable = Reader.read_boolean(reader)
 3841            elif tag == 'snapshot':
 3842                obj.snapshot = SnapshotReader.read_one(reader)
 3843            elif tag == 'sparse':
 3844                obj.sparse = Reader.read_boolean(reader)
 3845            elif tag == 'statistics':
 3846                obj.statistics = StatisticReader.read_many(reader)
 3847            elif tag == 'status':
 3848                obj.status = Reader.read_enum(types.DiskStatus, reader)
 3849            elif tag == 'storage_domain':
 3850                obj.storage_domain = StorageDomainReader.read_one(reader)
 3851            elif tag == 'storage_domains':
 3852                obj.storage_domains = StorageDomainReader.read_many(reader)
 3853            elif tag == 'storage_type':
 3854                obj.storage_type = Reader.read_enum(types.DiskStorageType, reader)
 3855            elif tag == 'template':
 3856                obj.template = TemplateReader.read_one(reader)
 3857            elif tag == 'total_size':
 3858                obj.total_size = Reader.read_integer(reader)
 3859            elif tag == 'uses_scsi_reservation':
 3860                obj.uses_scsi_reservation = Reader.read_boolean(reader)
 3861            elif tag == 'vm':
 3862                obj.vm = VmReader.read_one(reader)
 3863            elif tag == 'vms':
 3864                obj.vms = VmReader.read_many(reader)
 3865            elif tag == 'wipe_after_delete':
 3866                obj.wipe_after_delete = Reader.read_boolean(reader)
 3867            elif tag == 'link':
 3868                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 3869                reader.next_element()
 3870            else:
 3871                reader.next_element()
 3872        for link in links:
 3873            DiskSnapshotReader._process_link(link, obj)
 3874
 3875        # Discard the end tag:
 3876        reader.read()
 3877
 3878        return obj
 3879
 3880    @staticmethod
 3881    def read_many(reader):
 3882        # Do nothing if there aren't more tags:
 3883        objs = List()
 3884        if not reader.forward():
 3885            return objs
 3886
 3887        # Process the attributes:
 3888        objs.href = reader.get_attribute('href')
 3889
 3890        # Discard the start tag:
 3891        empty = reader.empty_element()
 3892        reader.read()
 3893        if empty:
 3894            return objs
 3895
 3896        # Process the inner elements:
 3897        while reader.forward():
 3898            objs.append(DiskSnapshotReader.read_one(reader))
 3899
 3900        # Discard the end tag:
 3901        reader.read()
 3902
 3903        return objs
 3904
 3905    @staticmethod
 3906    def _process_link(link, obj):
 3907        # Process the attributes:
 3908        rel = link[0]
 3909        href = link[1]
 3910        if href and rel:
 3911            if rel == "disksnapshots":
 3912                if obj.disk_snapshots is not None:
 3913                    obj.disk_snapshots.href = href
 3914                else:
 3915                    obj.disk_snapshots = List(href)
 3916            elif rel == "permissions":
 3917                if obj.permissions is not None:
 3918                    obj.permissions.href = href
 3919                else:
 3920                    obj.permissions = List(href)
 3921            elif rel == "statistics":
 3922                if obj.statistics is not None:
 3923                    obj.statistics.href = href
 3924                else:
 3925                    obj.statistics = List(href)
 3926            elif rel == "storagedomains":
 3927                if obj.storage_domains is not None:
 3928                    obj.storage_domains.href = href
 3929                else:
 3930                    obj.storage_domains = List(href)
 3931            elif rel == "vms":
 3932                if obj.vms is not None:
 3933                    obj.vms.href = href
 3934                else:
 3935                    obj.vms = List(href)
 3936
 3937
 3938class DisplayReader(Reader):
 3939
 3940    def __init__(self):
 3941        super(DisplayReader, self).__init__()
 3942
 3943    @staticmethod
 3944    def read_one(reader):
 3945        # Do nothing if there aren't more tags:
 3946        if not reader.forward():
 3947            return None
 3948
 3949        # Create the object:
 3950        obj = types.Display()
 3951
 3952        # Process the attributes:
 3953        obj.href = reader.get_attribute('href')
 3954
 3955        # Discard the start tag:
 3956        empty = reader.empty_element()
 3957        reader.read()
 3958        if empty:
 3959            return obj
 3960
 3961        # Process the inner elements:
 3962        links = []
 3963        while reader.forward():
 3964            tag = reader.node_name()
 3965            if tag == 'address':
 3966                obj.address = Reader.read_string(reader)
 3967            elif tag == 'allow_override':
 3968                obj.allow_override = Reader.read_boolean(reader)
 3969            elif tag == 'certificate':
 3970                obj.certificate = CertificateReader.read_one(reader)
 3971            elif tag == 'copy_paste_enabled':
 3972                obj.copy_paste_enabled = Reader.read_boolean(reader)
 3973            elif tag == 'disconnect_action':
 3974                obj.disconnect_action = Reader.read_string(reader)
 3975            elif tag == 'disconnect_action_delay':
 3976                obj.disconnect_action_delay = Reader.read_integer(reader)
 3977            elif tag == 'file_transfer_enabled':
 3978                obj.file_transfer_enabled = Reader.read_boolean(reader)
 3979            elif tag == 'keyboard_layout':
 3980                obj.keyboard_layout = Reader.read_string(reader)
 3981            elif tag == 'monitors':
 3982                obj.monitors = Reader.read_integer(reader)
 3983            elif tag == 'port':
 3984                obj.port = Reader.read_integer(reader)
 3985            elif tag == 'proxy':
 3986                obj.proxy = Reader.read_string(reader)
 3987            elif tag == 'secure_port':
 3988                obj.secure_port = Reader.read_integer(reader)
 3989            elif tag == 'single_qxl_pci':
 3990                obj.single_qxl_pci = Reader.read_boolean(reader)
 3991            elif tag == 'smartcard_enabled':
 3992                obj.smartcard_enabled = Reader.read_boolean(reader)
 3993            elif tag == 'type':
 3994                obj.type = Reader.read_enum(types.DisplayType, reader)
 3995            else:
 3996                reader.next_element()
 3997        for link in links:
 3998            DisplayReader._process_link(link, obj)
 3999
 4000        # Discard the end tag:
 4001        reader.read()
 4002
 4003        return obj
 4004
 4005    @staticmethod
 4006    def read_many(reader):
 4007        # Do nothing if there aren't more tags:
 4008        objs = List()
 4009        if not reader.forward():
 4010            return objs
 4011
 4012        # Process the attributes:
 4013        objs.href = reader.get_attribute('href')
 4014
 4015        # Discard the start tag:
 4016        empty = reader.empty_element()
 4017        reader.read()
 4018        if empty:
 4019            return objs
 4020
 4021        # Process the inner elements:
 4022        while reader.forward():
 4023            objs.append(DisplayReader.read_one(reader))
 4024
 4025        # Discard the end tag:
 4026        reader.read()
 4027
 4028        return objs
 4029
 4030
 4031class DnsReader(Reader):
 4032
 4033    def __init__(self):
 4034        super(DnsReader, self).__init__()
 4035
 4036    @staticmethod
 4037    def read_one(reader):
 4038        # Do nothing if there aren't more tags:
 4039        if not reader.forward():
 4040            return None
 4041
 4042        # Create the object:
 4043        obj = types.Dns()
 4044
 4045        # Process the attributes:
 4046        obj.href = reader.get_attribute('href')
 4047
 4048        # Discard the start tag:
 4049        empty = reader.empty_element()
 4050        reader.read()
 4051        if empty:
 4052            return obj
 4053
 4054        # Process the inner elements:
 4055        links = []
 4056        while reader.forward():
 4057            tag = reader.node_name()
 4058            if tag == 'search_domains':
 4059                obj.search_domains = HostReader.read_many(reader)
 4060            elif tag == 'servers':
 4061                obj.servers = HostReader.read_many(reader)
 4062            else:
 4063                reader.next_element()
 4064        for link in links:
 4065            DnsReader._process_link(link, obj)
 4066
 4067        # Discard the end tag:
 4068        reader.read()
 4069
 4070        return obj
 4071
 4072    @staticmethod
 4073    def read_many(reader):
 4074        # Do nothing if there aren't more tags:
 4075        objs = List()
 4076        if not reader.forward():
 4077            return objs
 4078
 4079        # Process the attributes:
 4080        objs.href = reader.get_attribute('href')
 4081
 4082        # Discard the start tag:
 4083        empty = reader.empty_element()
 4084        reader.read()
 4085        if empty:
 4086            return objs
 4087
 4088        # Process the inner elements:
 4089        while reader.forward():
 4090            objs.append(DnsReader.read_one(reader))
 4091
 4092        # Discard the end tag:
 4093        reader.read()
 4094
 4095        return objs
 4096
 4097
 4098class DnsResolverConfigurationReader(Reader):
 4099
 4100    def __init__(self):
 4101        super(DnsResolverConfigurationReader, self).__init__()
 4102
 4103    @staticmethod
 4104    def read_one(reader):
 4105        # Do nothing if there aren't more tags:
 4106        if not reader.forward():
 4107            return None
 4108
 4109        # Create the object:
 4110        obj = types.DnsResolverConfiguration()
 4111
 4112        # Process the attributes:
 4113        obj.href = reader.get_attribute('href')
 4114
 4115        # Discard the start tag:
 4116        empty = reader.empty_element()
 4117        reader.read()
 4118        if empty:
 4119            return obj
 4120
 4121        # Process the inner elements:
 4122        links = []
 4123        while reader.forward():
 4124            tag = reader.node_name()
 4125            if tag == 'name_servers':
 4126                obj.name_servers = Reader.read_strings(reader)
 4127            else:
 4128                reader.next_element()
 4129        for link in links:
 4130            DnsResolverConfigurationReader._process_link(link, obj)
 4131
 4132        # Discard the end tag:
 4133        reader.read()
 4134
 4135        return obj
 4136
 4137    @staticmethod
 4138    def read_many(reader):
 4139        # Do nothing if there aren't more tags:
 4140        objs = List()
 4141        if not reader.forward():
 4142            return objs
 4143
 4144        # Process the attributes:
 4145        objs.href = reader.get_attribute('href')
 4146
 4147        # Discard the start tag:
 4148        empty = reader.empty_element()
 4149        reader.read()
 4150        if empty:
 4151            return objs
 4152
 4153        # Process the inner elements:
 4154        while reader.forward():
 4155            objs.append(DnsResolverConfigurationReader.read_one(reader))
 4156
 4157        # Discard the end tag:
 4158        reader.read()
 4159
 4160        return objs
 4161
 4162
 4163class DomainReader(Reader):
 4164
 4165    def __init__(self):
 4166        super(DomainReader, self).__init__()
 4167
 4168    @staticmethod
 4169    def read_one(reader):
 4170        # Do nothing if there aren't more tags:
 4171        if not reader.forward():
 4172            return None
 4173
 4174        # Create the object:
 4175        obj = types.Domain()
 4176
 4177        # Process the attributes:
 4178        obj.href = reader.get_attribute('href')
 4179        value = reader.get_attribute('id')
 4180        if value is not None:
 4181            obj.id = value
 4182
 4183        # Discard the start tag:
 4184        empty = reader.empty_element()
 4185        reader.read()
 4186        if empty:
 4187            return obj
 4188
 4189        # Process the inner elements:
 4190        links = []
 4191        while reader.forward():
 4192            tag = reader.node_name()
 4193            if tag == 'comment':
 4194                obj.comment = Reader.read_string(reader)
 4195            elif tag == 'description':
 4196                obj.description = Reader.read_string(reader)
 4197            elif tag == 'groups':
 4198                obj.groups = GroupReader.read_many(reader)
 4199            elif tag == 'name':
 4200                obj.name = Reader.read_string(reader)
 4201            elif tag == 'user':
 4202                obj.user = UserReader.read_one(reader)
 4203            elif tag == 'users':
 4204                obj.users = UserReader.read_many(reader)
 4205            elif tag == 'link':
 4206                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 4207                reader.next_element()
 4208            else:
 4209                reader.next_element()
 4210        for link in links:
 4211            DomainReader._process_link(link, obj)
 4212
 4213        # Discard the end tag:
 4214        reader.read()
 4215
 4216        return obj
 4217
 4218    @staticmethod
 4219    def read_many(reader):
 4220        # Do nothing if there aren't more tags:
 4221        objs = List()
 4222        if not reader.forward():
 4223            return objs
 4224
 4225        # Process the attributes:
 4226        objs.href = reader.get_attribute('href')
 4227
 4228        # Discard the start tag:
 4229        empty = reader.empty_element()
 4230        reader.read()
 4231        if empty:
 4232            return objs
 4233
 4234        # Process the inner elements:
 4235        while reader.forward():
 4236            objs.append(DomainReader.read_one(reader))
 4237
 4238        # Discard the end tag:
 4239        reader.read()
 4240
 4241        return objs
 4242
 4243    @staticmethod
 4244    def _process_link(link, obj):
 4245        # Process the attributes:
 4246        rel = link[0]
 4247        href = link[1]
 4248        if href and rel:
 4249            if rel == "groups":
 4250                if obj.groups is not None:
 4251                    obj.groups.href = href
 4252                else:
 4253                    obj.groups = List(href)
 4254            elif rel == "users":
 4255                if obj.users is not None:
 4256                    obj.users.href = href
 4257                else:
 4258                    obj.users = List(href)
 4259
 4260
 4261class DynamicCpuReader(Reader):
 4262
 4263    def __init__(self):
 4264        super(DynamicCpuReader, self).__init__()
 4265
 4266    @staticmethod
 4267    def read_one(reader):
 4268        # Do nothing if there aren't more tags:
 4269        if not reader.forward():
 4270            return None
 4271
 4272        # Create the object:
 4273        obj = types.DynamicCpu()
 4274
 4275        # Process the attributes:
 4276        obj.href = reader.get_attribute('href')
 4277
 4278        # Discard the start tag:
 4279        empty = reader.empty_element()
 4280        reader.read()
 4281        if empty:
 4282            return obj
 4283
 4284        # Process the inner elements:
 4285        links = []
 4286        while reader.forward():
 4287            tag = reader.node_name()
 4288            if tag == 'cpu_tune':
 4289                obj.cpu_tune = CpuTuneReader.read_one(reader)
 4290            elif tag == 'topology':
 4291                obj.topology = CpuTopologyReader.read_one(reader)
 4292            else:
 4293                reader.next_element()
 4294        for link in links:
 4295            DynamicCpuReader._process_link(link, obj)
 4296
 4297        # Discard the end tag:
 4298        reader.read()
 4299
 4300        return obj
 4301
 4302    @staticmethod
 4303    def read_many(reader):
 4304        # Do nothing if there aren't more tags:
 4305        objs = List()
 4306        if not reader.forward():
 4307            return objs
 4308
 4309        # Process the attributes:
 4310        objs.href = reader.get_attribute('href')
 4311
 4312        # Discard the start tag:
 4313        empty = reader.empty_element()
 4314        reader.read()
 4315        if empty:
 4316            return objs
 4317
 4318        # Process the inner elements:
 4319        while reader.forward():
 4320            objs.append(DynamicCpuReader.read_one(reader))
 4321
 4322        # Discard the end tag:
 4323        reader.read()
 4324
 4325        return objs
 4326
 4327
 4328class EntityProfileDetailReader(Reader):
 4329
 4330    def __init__(self):
 4331        super(EntityProfileDetailReader, self).__init__()
 4332
 4333    @staticmethod
 4334    def read_one(reader):
 4335        # Do nothing if there aren't more tags:
 4336        if not reader.forward():
 4337            return None
 4338
 4339        # Create the object:
 4340        obj = types.EntityProfileDetail()
 4341
 4342        # Process the attributes:
 4343        obj.href = reader.get_attribute('href')
 4344
 4345        # Discard the start tag:
 4346        empty = reader.empty_element()
 4347        reader.read()
 4348        if empty:
 4349            return obj
 4350
 4351        # Process the inner elements:
 4352        links = []
 4353        while reader.forward():
 4354            tag = reader.node_name()
 4355            if tag == 'profile_details':
 4356                obj.profile_details = ProfileDetailReader.read_many(reader)
 4357            else:
 4358                reader.next_element()
 4359        for link in links:
 4360            EntityProfileDetailReader._process_link(link, obj)
 4361
 4362        # Discard the end tag:
 4363        reader.read()
 4364
 4365        return obj
 4366
 4367    @staticmethod
 4368    def read_many(reader):
 4369        # Do nothing if there aren't more tags:
 4370        objs = List()
 4371        if not reader.forward():
 4372            return objs
 4373
 4374        # Process the attributes:
 4375        objs.href = reader.get_attribute('href')
 4376
 4377        # Discard the start tag:
 4378        empty = reader.empty_element()
 4379        reader.read()
 4380        if empty:
 4381            return objs
 4382
 4383        # Process the inner elements:
 4384        while reader.forward():
 4385            objs.append(EntityProfileDetailReader.read_one(reader))
 4386
 4387        # Discard the end tag:
 4388        reader.read()
 4389
 4390        return objs
 4391
 4392
 4393class ErrorHandlingReader(Reader):
 4394
 4395    def __init__(self):
 4396        super(ErrorHandlingReader, self).__init__()
 4397
 4398    @staticmethod
 4399    def read_one(reader):
 4400        # Do nothing if there aren't more tags:
 4401        if not reader.forward():
 4402            return None
 4403
 4404        # Create the object:
 4405        obj = types.ErrorHandling()
 4406
 4407        # Process the attributes:
 4408        obj.href = reader.get_attribute('href')
 4409
 4410        # Discard the start tag:
 4411        empty = reader.empty_element()
 4412        reader.read()
 4413        if empty:
 4414            return obj
 4415
 4416        # Process the inner elements:
 4417        links = []
 4418        while reader.forward():
 4419            tag = reader.node_name()
 4420            if tag == 'on_error':
 4421                obj.on_error = Reader.read_enum(types.MigrateOnError, reader)
 4422            else:
 4423                reader.next_element()
 4424        for link in links:
 4425            ErrorHandlingReader._process_link(link, obj)
 4426
 4427        # Discard the end tag:
 4428        reader.read()
 4429
 4430        return obj
 4431
 4432    @staticmethod
 4433    def read_many(reader):
 4434        # Do nothing if there aren't more tags:
 4435        objs = List()
 4436        if not reader.forward():
 4437            return objs
 4438
 4439        # Process the attributes:
 4440        objs.href = reader.get_attribute('href')
 4441
 4442        # Discard the start tag:
 4443        empty = reader.empty_element()
 4444        reader.read()
 4445        if empty:
 4446            return objs
 4447
 4448        # Process the inner elements:
 4449        while reader.forward():
 4450            objs.append(ErrorHandlingReader.read_one(reader))
 4451
 4452        # Discard the end tag:
 4453        reader.read()
 4454
 4455        return objs
 4456
 4457
 4458class EventReader(Reader):
 4459
 4460    def __init__(self):
 4461        super(EventReader, self).__init__()
 4462
 4463    @staticmethod
 4464    def read_one(reader):
 4465        # Do nothing if there aren't more tags:
 4466        if not reader.forward():
 4467            return None
 4468
 4469        # Create the object:
 4470        obj = types.Event()
 4471
 4472        # Process the attributes:
 4473        obj.href = reader.get_attribute('href')
 4474        value = reader.get_attribute('id')
 4475        if value is not None:
 4476            obj.id = value
 4477
 4478        # Discard the start tag:
 4479        empty = reader.empty_element()
 4480        reader.read()
 4481        if empty:
 4482            return obj
 4483
 4484        # Process the inner elements:
 4485        links = []
 4486        while reader.forward():
 4487            tag = reader.node_name()
 4488            if tag == 'cluster':
 4489                obj.cluster = ClusterReader.read_one(reader)
 4490            elif tag == 'code':
 4491                obj.code = Reader.read_integer(reader)
 4492            elif tag == 'comment':
 4493                obj.comment = Reader.read_string(reader)
 4494            elif tag == 'correlation_id':
 4495                obj.correlation_id = Reader.read_string(reader)
 4496            elif tag == 'custom_data':
 4497                obj.custom_data = Reader.read_string(reader)
 4498            elif tag == 'custom_id':
 4499                obj.custom_id = Reader.read_integer(reader)
 4500            elif tag == 'data_center':
 4501                obj.data_center = DataCenterReader.read_one(reader)
 4502            elif tag == 'description':
 4503                obj.description = Reader.read_string(reader)
 4504            elif tag == 'flood_rate':
 4505                obj.flood_rate = Reader.read_integer(reader)
 4506            elif tag == 'host':
 4507                obj.host = HostReader.read_one(reader)
 4508            elif tag == 'index':
 4509                obj.index = Reader.read_integer(reader)
 4510            elif tag == 'log_on_host':
 4511                obj.log_on_host = Reader.read_boolean(reader)
 4512            elif tag == 'name':
 4513                obj.name = Reader.read_string(reader)
 4514            elif tag == 'origin':
 4515                obj.origin = Reader.read_string(reader)
 4516            elif tag == 'severity':
 4517                obj.severity = Reader.read_enum(types.LogSeverity, reader)
 4518            elif tag == 'storage_domain':
 4519                obj.storage_domain = StorageDomainReader.read_one(reader)
 4520            elif tag == 'template':
 4521                obj.template = TemplateReader.read_one(reader)
 4522            elif tag == 'time':
 4523                obj.time = Reader.read_date(reader)
 4524            elif tag == 'user':
 4525                obj.user = UserReader.read_one(reader)
 4526            elif tag == 'vm':
 4527                obj.vm = VmReader.read_one(reader)
 4528            else:
 4529                reader.next_element()
 4530        for link in links:
 4531            EventReader._process_link(link, obj)
 4532
 4533        # Discard the end tag:
 4534        reader.read()
 4535
 4536        return obj
 4537
 4538    @staticmethod
 4539    def read_many(reader):
 4540        # Do nothing if there aren't more tags:
 4541        objs = List()
 4542        if not reader.forward():
 4543            return objs
 4544
 4545        # Process the attributes:
 4546        objs.href = reader.get_attribute('href')
 4547
 4548        # Discard the start tag:
 4549        empty = reader.empty_element()
 4550        reader.read()
 4551        if empty:
 4552            return objs
 4553
 4554        # Process the inner elements:
 4555        while reader.forward():
 4556            objs.append(EventReader.read_one(reader))
 4557
 4558        # Discard the end tag:
 4559        reader.read()
 4560
 4561        return objs
 4562
 4563
 4564class EventSubscriptionReader(Reader):
 4565
 4566    def __init__(self):
 4567        super(EventSubscriptionReader, self).__init__()
 4568
 4569    @staticmethod
 4570    def read_one(reader):
 4571        # Do nothing if there aren't more tags:
 4572        if not reader.forward():
 4573            return None
 4574
 4575        # Create the object:
 4576        obj = types.EventSubscription()
 4577
 4578        # Process the attributes:
 4579        obj.href = reader.get_attribute('href')
 4580        value = reader.get_attribute('id')
 4581        if value is not None:
 4582            obj.id = value
 4583
 4584        # Discard the start tag:
 4585        empty = reader.empty_element()
 4586        reader.read()
 4587        if empty:
 4588            return obj
 4589
 4590        # Process the inner elements:
 4591        links = []
 4592        while reader.forward():
 4593            tag = reader.node_name()
 4594            if tag == 'address':
 4595                obj.address = Reader.read_string(reader)
 4596            elif tag == 'comment':
 4597                obj.comment = Reader.read_string(reader)
 4598            elif tag == 'description':
 4599                obj.description = Reader.read_string(reader)
 4600            elif tag == 'event':
 4601                obj.event = Reader.read_enum(types.NotifiableEvent, reader)
 4602            elif tag == 'name':
 4603                obj.name = Reader.read_string(reader)
 4604            elif tag == 'notification_method':
 4605                obj.notification_method = Reader.read_enum(types.NotificationMethod, reader)
 4606            elif tag == 'user':
 4607                obj.user = UserReader.read_one(reader)
 4608            else:
 4609                reader.next_element()
 4610        for link in links:
 4611            EventSubscriptionReader._process_link(link, obj)
 4612
 4613        # Discard the end tag:
 4614        reader.read()
 4615
 4616        return obj
 4617
 4618    @staticmethod
 4619    def read_many(reader):
 4620        # Do nothing if there aren't more tags:
 4621        objs = List()
 4622        if not reader.forward():
 4623            return objs
 4624
 4625        # Process the attributes:
 4626        objs.href = reader.get_attribute('href')
 4627
 4628        # Discard the start tag:
 4629        empty = reader.empty_element()
 4630        reader.read()
 4631        if empty:
 4632            return objs
 4633
 4634        # Process the inner elements:
 4635        while reader.forward():
 4636            objs.append(EventSubscriptionReader.read_one(reader))
 4637
 4638        # Discard the end tag:
 4639        reader.read()
 4640
 4641        return objs
 4642
 4643
 4644class ExternalComputeResourceReader(Reader):
 4645
 4646    def __init__(self):
 4647        super(ExternalComputeResourceReader, self).__init__()
 4648
 4649    @staticmethod
 4650    def read_one(reader):
 4651        # Do nothing if there aren't more tags:
 4652        if not reader.forward():
 4653            return None
 4654
 4655        # Create the object:
 4656        obj = types.ExternalComputeResource()
 4657
 4658        # Process the attributes:
 4659        obj.href = reader.get_attribute('href')
 4660        value = reader.get_attribute('id')
 4661        if value is not None:
 4662            obj.id = value
 4663
 4664        # Discard the start tag:
 4665        empty = reader.empty_element()
 4666        reader.read()
 4667        if empty:
 4668            return obj
 4669
 4670        # Process the inner elements:
 4671        links = []
 4672        while reader.forward():
 4673            tag = reader.node_name()
 4674            if tag == 'comment':
 4675                obj.comment = Reader.read_string(reader)
 4676            elif tag == 'description':
 4677                obj.description = Reader.read_string(reader)
 4678            elif tag == 'external_host_provider':
 4679                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
 4680            elif tag == 'name':
 4681                obj.name = Reader.read_string(reader)
 4682            elif tag == 'provider':
 4683                obj.provider = Reader.read_string(reader)
 4684            elif tag == 'url':
 4685                obj.url = Reader.read_string(reader)
 4686            elif tag == 'user':
 4687                obj.user = Reader.read_string(reader)
 4688            else:
 4689                reader.next_element()
 4690        for link in links:
 4691            ExternalComputeResourceReader._process_link(link, obj)
 4692
 4693        # Discard the end tag:
 4694        reader.read()
 4695
 4696        return obj
 4697
 4698    @staticmethod
 4699    def read_many(reader):
 4700        # Do nothing if there aren't more tags:
 4701        objs = List()
 4702        if not reader.forward():
 4703            return objs
 4704
 4705        # Process the attributes:
 4706        objs.href = reader.get_attribute('href')
 4707
 4708        # Discard the start tag:
 4709        empty = reader.empty_element()
 4710        reader.read()
 4711        if empty:
 4712            return objs
 4713
 4714        # Process the inner elements:
 4715        while reader.forward():
 4716            objs.append(ExternalComputeResourceReader.read_one(reader))
 4717
 4718        # Discard the end tag:
 4719        reader.read()
 4720
 4721        return objs
 4722
 4723
 4724class ExternalDiscoveredHostReader(Reader):
 4725
 4726    def __init__(self):
 4727        super(ExternalDiscoveredHostReader, self).__init__()
 4728
 4729    @staticmethod
 4730    def read_one(reader):
 4731        # Do nothing if there aren't more tags:
 4732        if not reader.forward():
 4733            return None
 4734
 4735        # Create the object:
 4736        obj = types.ExternalDiscoveredHost()
 4737
 4738        # Process the attributes:
 4739        obj.href = reader.get_attribute('href')
 4740        value = reader.get_attribute('id')
 4741        if value is not None:
 4742            obj.id = value
 4743
 4744        # Discard the start tag:
 4745        empty = reader.empty_element()
 4746        reader.read()
 4747        if empty:
 4748            return obj
 4749
 4750        # Process the inner elements:
 4751        links = []
 4752        while reader.forward():
 4753            tag = reader.node_name()
 4754            if tag == 'comment':
 4755                obj.comment = Reader.read_string(reader)
 4756            elif tag == 'description':
 4757                obj.description = Reader.read_string(reader)
 4758            elif tag == 'external_host_provider':
 4759                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
 4760            elif tag == 'ip':
 4761                obj.ip = Reader.read_string(reader)
 4762            elif tag == 'last_report':
 4763                obj.last_report = Reader.read_string(reader)
 4764            elif tag == 'mac':
 4765                obj.mac = Reader.read_string(reader)
 4766            elif tag == 'name':
 4767                obj.name = Reader.read_string(reader)
 4768            elif tag == 'subnet_name':
 4769                obj.subnet_name = Reader.read_string(reader)
 4770            else:
 4771                reader.next_element()
 4772        for link in links:
 4773            ExternalDiscoveredHostReader._process_link(link, obj)
 4774
 4775        # Discard the end tag:
 4776        reader.read()
 4777
 4778        return obj
 4779
 4780    @staticmethod
 4781    def read_many(reader):
 4782        # Do nothing if there aren't more tags:
 4783        objs = List()
 4784        if not reader.forward():
 4785            return objs
 4786
 4787        # Process the attributes:
 4788        objs.href = reader.get_attribute('href')
 4789
 4790        # Discard the start tag:
 4791        empty = reader.empty_element()
 4792        reader.read()
 4793        if empty:
 4794            return objs
 4795
 4796        # Process the inner elements:
 4797        while reader.forward():
 4798            objs.append(ExternalDiscoveredHostReader.read_one(reader))
 4799
 4800        # Discard the end tag:
 4801        reader.read()
 4802
 4803        return objs
 4804
 4805
 4806class ExternalHostReader(Reader):
 4807
 4808    def __init__(self):
 4809        super(ExternalHostReader, self).__init__()
 4810
 4811    @staticmethod
 4812    def read_one(reader):
 4813        # Do nothing if there aren't more tags:
 4814        if not reader.forward():
 4815            return None
 4816
 4817        # Create the object:
 4818        obj = types.ExternalHost()
 4819
 4820        # Process the attributes:
 4821        obj.href = reader.get_attribute('href')
 4822        value = reader.get_attribute('id')
 4823        if value is not None:
 4824            obj.id = value
 4825
 4826        # Discard the start tag:
 4827        empty = reader.empty_element()
 4828        reader.read()
 4829        if empty:
 4830            return obj
 4831
 4832        # Process the inner elements:
 4833        links = []
 4834        while reader.forward():
 4835            tag = reader.node_name()
 4836            if tag == 'address':
 4837                obj.address = Reader.read_string(reader)
 4838            elif tag == 'comment':
 4839                obj.comment = Reader.read_string(reader)
 4840            elif tag == 'description':
 4841                obj.description = Reader.read_string(reader)
 4842            elif tag == 'external_host_provider':
 4843                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
 4844            elif tag == 'name':
 4845                obj.name = Reader.read_string(reader)
 4846            else:
 4847                reader.next_element()
 4848        for link in links:
 4849            ExternalHostReader._process_link(link, obj)
 4850
 4851        # Discard the end tag:
 4852        reader.read()
 4853
 4854        return obj
 4855
 4856    @staticmethod
 4857    def read_many(reader):
 4858        # Do nothing if there aren't more tags:
 4859        objs = List()
 4860        if not reader.forward():
 4861            return objs
 4862
 4863        # Process the attributes:
 4864        objs.href = reader.get_attribute('href')
 4865
 4866        # Discard the start tag:
 4867        empty = reader.empty_element()
 4868        reader.read()
 4869        if empty:
 4870            return objs
 4871
 4872        # Process the inner elements:
 4873        while reader.forward():
 4874            objs.append(ExternalHostReader.read_one(reader))
 4875
 4876        # Discard the end tag:
 4877        reader.read()
 4878
 4879        return objs
 4880
 4881
 4882class ExternalHostGroupReader(Reader):
 4883
 4884    def __init__(self):
 4885        super(ExternalHostGroupReader, self).__init__()
 4886
 4887    @staticmethod
 4888    def read_one(reader):
 4889        # Do nothing if there aren't more tags:
 4890        if not reader.forward():
 4891            return None
 4892
 4893        # Create the object:
 4894        obj = types.ExternalHostGroup()
 4895
 4896        # Process the attributes:
 4897        obj.href = reader.get_attribute('href')
 4898        value = reader.get_attribute('id')
 4899        if value is not None:
 4900            obj.id = value
 4901
 4902        # Discard the start tag:
 4903        empty = reader.empty_element()
 4904        reader.read()
 4905        if empty:
 4906            return obj
 4907
 4908        # Process the inner elements:
 4909        links = []
 4910        while reader.forward():
 4911            tag = reader.node_name()
 4912            if tag == 'architecture_name':
 4913                obj.architecture_name = Reader.read_string(reader)
 4914            elif tag == 'comment':
 4915                obj.comment = Reader.read_string(reader)
 4916            elif tag == 'description':
 4917                obj.description = Reader.read_string(reader)
 4918            elif tag == 'domain_name':
 4919                obj.domain_name = Reader.read_string(reader)
 4920            elif tag == 'external_host_provider':
 4921                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
 4922            elif tag == 'name':
 4923                obj.name = Reader.read_string(reader)
 4924            elif tag == 'operating_system_name':
 4925                obj.operating_system_name = Reader.read_string(reader)
 4926            elif tag == 'subnet_name':
 4927                obj.subnet_name = Reader.read_string(reader)
 4928            else:
 4929                reader.next_element()
 4930        for link in links:
 4931            ExternalHostGroupReader._process_link(link, obj)
 4932
 4933        # Discard the end tag:
 4934        reader.read()
 4935
 4936        return obj
 4937
 4938    @staticmethod
 4939    def read_many(reader):
 4940        # Do nothing if there aren't more tags:
 4941        objs = List()
 4942        if not reader.forward():
 4943            return objs
 4944
 4945        # Process the attributes:
 4946        objs.href = reader.get_attribute('href')
 4947
 4948        # Discard the start tag:
 4949        empty = reader.empty_element()
 4950        reader.read()
 4951        if empty:
 4952            return objs
 4953
 4954        # Process the inner elements:
 4955        while reader.forward():
 4956            objs.append(ExternalHostGroupReader.read_one(reader))
 4957
 4958        # Discard the end tag:
 4959        reader.read()
 4960
 4961        return objs
 4962
 4963
 4964class ExternalHostProviderReader(Reader):
 4965
 4966    def __init__(self):
 4967        super(ExternalHostProviderReader, self).__init__()
 4968
 4969    @staticmethod
 4970    def read_one(reader):
 4971        # Do nothing if there aren't more tags:
 4972        if not reader.forward():
 4973            return None
 4974
 4975        # Create the object:
 4976        obj = types.ExternalHostProvider()
 4977
 4978        # Process the attributes:
 4979        obj.href = reader.get_attribute('href')
 4980        value = reader.get_attribute('id')
 4981        if value is not None:
 4982            obj.id = value
 4983
 4984        # Discard the start tag:
 4985        empty = reader.empty_element()
 4986        reader.read()
 4987        if empty:
 4988            return obj
 4989
 4990        # Process the inner elements:
 4991        links = []
 4992        while reader.forward():
 4993            tag = reader.node_name()
 4994            if tag == 'authentication_url':
 4995                obj.authentication_url = Reader.read_string(reader)
 4996            elif tag == 'certificates':
 4997                obj.certificates = CertificateReader.read_many(reader)
 4998            elif tag == 'comment':
 4999                obj.comment = Reader.read_string(reader)
 5000            elif tag == 'compute_resources':
 5001                obj.compute_resources = ExternalComputeResourceReader.read_many(reader)
 5002            elif tag == 'description':
 5003                obj.description = Reader.read_string(reader)
 5004            elif tag == 'discovered_hosts':
 5005                obj.discovered_hosts = ExternalDiscoveredHostReader.read_many(reader)
 5006            elif tag == 'host_groups':
 5007                obj.host_groups = ExternalHostGroupReader.read_many(reader)
 5008            elif tag == 'hosts':
 5009                obj.hosts = HostReader.read_many(reader)
 5010            elif tag == 'name':
 5011                obj.name = Reader.read_string(reader)
 5012            elif tag == 'password':
 5013                obj.password = Reader.read_string(reader)
 5014            elif tag == 'properties':
 5015                obj.properties = PropertyReader.read_many(reader)
 5016            elif tag == 'requires_authentication':
 5017                obj.requires_authentication = Reader.read_boolean(reader)
 5018            elif tag == 'url':
 5019                obj.url = Reader.read_string(reader)
 5020            elif tag == 'username':
 5021                obj.username = Reader.read_string(reader)
 5022            elif tag == 'link':
 5023                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 5024                reader.next_element()
 5025            else:
 5026                reader.next_element()
 5027        for link in links:
 5028            ExternalHostProviderReader._process_link(link, obj)
 5029
 5030        # Discard the end tag:
 5031        reader.read()
 5032
 5033        return obj
 5034
 5035    @staticmethod
 5036    def read_many(reader):
 5037        # Do nothing if there aren't more tags:
 5038        objs = List()
 5039        if not reader.forward():
 5040            return objs
 5041
 5042        # Process the attributes:
 5043        objs.href = reader.get_attribute('href')
 5044
 5045        # Discard the start tag:
 5046        empty = reader.empty_element()
 5047        reader.read()
 5048        if empty:
 5049            return objs
 5050
 5051        # Process the inner elements:
 5052        while reader.forward():
 5053            objs.append(ExternalHostProviderReader.read_one(reader))
 5054
 5055        # Discard the end tag:
 5056        reader.read()
 5057
 5058        return objs
 5059
 5060    @staticmethod
 5061    def _process_link(link, obj):
 5062        # Process the attributes:
 5063        rel = link[0]
 5064        href = link[1]
 5065        if href and rel:
 5066            if rel == "certificates":
 5067                if obj.certificates is not None:
 5068                    obj.certificates.href = href
 5069                else:
 5070                    obj.certificates = List(href)
 5071            elif rel == "computeresources":
 5072                if obj.compute_resources is not None:
 5073                    obj.compute_resources.href = href
 5074                else:
 5075                    obj.compute_resources = List(href)
 5076            elif rel == "discoveredhosts":
 5077                if obj.discovered_hosts is not None:
 5078                    obj.discovered_hosts.href = href
 5079                else:
 5080                    obj.discovered_hosts = List(href)
 5081            elif rel == "hostgroups":
 5082                if obj.host_groups is not None:
 5083                    obj.host_groups.href = href
 5084                else:
 5085                    obj.host_groups = List(href)
 5086            elif rel == "hosts":
 5087                if obj.hosts is not None:
 5088                    obj.hosts.href = href
 5089                else:
 5090                    obj.hosts = List(href)
 5091
 5092
 5093class ExternalNetworkProviderConfigurationReader(Reader):
 5094
 5095    def __init__(self):
 5096        super(ExternalNetworkProviderConfigurationReader, self).__init__()
 5097
 5098    @staticmethod
 5099    def read_one(reader):
 5100        # Do nothing if there aren't more tags:
 5101        if not reader.forward():
 5102            return None
 5103
 5104        # Create the object:
 5105        obj = types.ExternalNetworkProviderConfiguration()
 5106
 5107        # Process the attributes:
 5108        obj.href = reader.get_attribute('href')
 5109        value = reader.get_attribute('id')
 5110        if value is not None:
 5111            obj.id = value
 5112
 5113        # Discard the start tag:
 5114        empty = reader.empty_element()
 5115        reader.read()
 5116        if empty:
 5117            return obj
 5118
 5119        # Process the inner elements:
 5120        links = []
 5121        while reader.forward():
 5122            tag = reader.node_name()
 5123            if tag == 'comment':
 5124                obj.comment = Reader.read_string(reader)
 5125            elif tag == 'description':
 5126                obj.description = Reader.read_string(reader)
 5127            elif tag == 'external_network_provider':
 5128                obj.external_network_provider = ExternalProviderReader.read_one(reader)
 5129            elif tag == 'host':
 5130                obj.host = HostReader.read_one(reader)
 5131            elif tag == 'name':
 5132                obj.name = Reader.read_string(reader)
 5133            else:
 5134                reader.next_element()
 5135        for link in links:
 5136            ExternalNetworkProviderConfigurationReader._process_link(link, obj)
 5137
 5138        # Discard the end tag:
 5139        reader.read()
 5140
 5141        return obj
 5142
 5143    @staticmethod
 5144    def read_many(reader):
 5145        # Do nothing if there aren't more tags:
 5146        objs = List()
 5147        if not reader.forward():
 5148            return objs
 5149
 5150        # Process the attributes:
 5151        objs.href = reader.get_attribute('href')
 5152
 5153        # Discard the start tag:
 5154        empty = reader.empty_element()
 5155        reader.read()
 5156        if empty:
 5157            return objs
 5158
 5159        # Process the inner elements:
 5160        while reader.forward():
 5161            objs.append(ExternalNetworkProviderConfigurationReader.read_one(reader))
 5162
 5163        # Discard the end tag:
 5164        reader.read()
 5165
 5166        return objs
 5167
 5168
 5169class ExternalProviderReader(Reader):
 5170
 5171    def __init__(self):
 5172        super(ExternalProviderReader, self).__init__()
 5173
 5174    @staticmethod
 5175    def read_one(reader):
 5176        # Do nothing if there aren't more tags:
 5177        if not reader.forward():
 5178            return None
 5179
 5180        # Create the object:
 5181        obj = types.ExternalProvider()
 5182
 5183        # Process the attributes:
 5184        obj.href = reader.get_attribute('href')
 5185        value = reader.get_attribute('id')
 5186        if value is not None:
 5187            obj.id = value
 5188
 5189        # Discard the start tag:
 5190        empty = reader.empty_element()
 5191        reader.read()
 5192        if empty:
 5193            return obj
 5194
 5195        # Process the inner elements:
 5196        links = []
 5197        while reader.forward():
 5198            tag = reader.node_name()
 5199            if tag == 'authentication_url':
 5200                obj.authentication_url = Reader.read_string(reader)
 5201            elif tag == 'comment':
 5202                obj.comment = Reader.read_string(reader)
 5203            elif tag == 'description':
 5204                obj.description = Reader.read_string(reader)
 5205            elif tag == 'name':
 5206                obj.name = Reader.read_string(reader)
 5207            elif tag == 'password':
 5208                obj.password = Reader.read_string(reader)
 5209            elif tag == 'properties':
 5210                obj.properties = PropertyReader.read_many(reader)
 5211            elif tag == 'requires_authentication':
 5212                obj.requires_authentication = Reader.read_boolean(reader)
 5213            elif tag == 'url':
 5214                obj.url = Reader.read_string(reader)
 5215            elif tag == 'username':
 5216                obj.username = Reader.read_string(reader)
 5217            else:
 5218                reader.next_element()
 5219        for link in links:
 5220            ExternalProviderReader._process_link(link, obj)
 5221
 5222        # Discard the end tag:
 5223        reader.read()
 5224
 5225        return obj
 5226
 5227    @staticmethod
 5228    def read_many(reader):
 5229        # Do nothing if there aren't more tags:
 5230        objs = List()
 5231        if not reader.forward():
 5232            return objs
 5233
 5234        # Process the attributes:
 5235        objs.href = reader.get_attribute('href')
 5236
 5237        # Discard the start tag:
 5238        empty = reader.empty_element()
 5239        reader.read()
 5240        if empty:
 5241            return objs
 5242
 5243        # Process the inner elements:
 5244        while reader.forward():
 5245            objs.append(ExternalProviderReader.read_one(reader))
 5246
 5247        # Discard the end tag:
 5248        reader.read()
 5249
 5250        return objs
 5251
 5252
 5253class ExternalTemplateImportReader(Reader):
 5254
 5255    def __init__(self):
 5256        super(ExternalTemplateImportReader, self).__init__()
 5257
 5258    @staticmethod
 5259    def read_one(reader):
 5260        # Do nothing if there aren't more tags:
 5261        if not reader.forward():
 5262            return None
 5263
 5264        # Create the object:
 5265        obj = types.ExternalTemplateImport()
 5266
 5267        # Process the attributes:
 5268        obj.href = reader.get_attribute('href')
 5269
 5270        # Discard the start tag:
 5271        empty = reader.empty_element()
 5272        reader.read()
 5273        if empty:
 5274            return obj
 5275
 5276        # Process the inner elements:
 5277        links = []
 5278        while reader.forward():
 5279            tag = reader.node_name()
 5280            if tag == 'clone':
 5281                obj.clone = Reader.read_boolean(reader)
 5282            elif tag == 'cluster':
 5283                obj.cluster = ClusterReader.read_one(reader)
 5284            elif tag == 'cpu_profile':
 5285                obj.cpu_profile = CpuProfileReader.read_one(reader)
 5286            elif tag == 'host':
 5287                obj.host = HostReader.read_one(reader)
 5288            elif tag == 'quota':
 5289                obj.quota = QuotaReader.read_one(reader)
 5290            elif tag == 'storage_domain':
 5291                obj.storage_domain = StorageDomainReader.read_one(reader)
 5292            elif tag == 'template':
 5293                obj.template = TemplateReader.read_one(reader)
 5294            elif tag == 'url':
 5295                obj.url = Reader.read_string(reader)
 5296            else:
 5297                reader.next_element()
 5298        for link in links:
 5299            ExternalTemplateImportReader._process_link(link, obj)
 5300
 5301        # Discard the end tag:
 5302        reader.read()
 5303
 5304        return obj
 5305
 5306    @staticmethod
 5307    def read_many(reader):
 5308        # Do nothing if there aren't more tags:
 5309        objs = List()
 5310        if not reader.forward():
 5311            return objs
 5312
 5313        # Process the attributes:
 5314        objs.href = reader.get_attribute('href')
 5315
 5316        # Discard the start tag:
 5317        empty = reader.empty_element()
 5318        reader.read()
 5319        if empty:
 5320            return objs
 5321
 5322        # Process the inner elements:
 5323        while reader.forward():
 5324            objs.append(ExternalTemplateImportReader.read_one(reader))
 5325
 5326        # Discard the end tag:
 5327        reader.read()
 5328
 5329        return objs
 5330
 5331
 5332class ExternalVmImportReader(Reader):
 5333
 5334    def __init__(self):
 5335        super(ExternalVmImportReader, self).__init__()
 5336
 5337    @staticmethod
 5338    def read_one(reader):
 5339        # Do nothing if there aren't more tags:
 5340        if not reader.forward():
 5341            return None
 5342
 5343        # Create the object:
 5344        obj = types.ExternalVmImport()
 5345
 5346        # Process the attributes:
 5347        obj.href = reader.get_attribute('href')
 5348
 5349        # Discard the start tag:
 5350        empty = reader.empty_element()
 5351        reader.read()
 5352        if empty:
 5353            return obj
 5354
 5355        # Process the inner elements:
 5356        links = []
 5357        while reader.forward():
 5358            tag = reader.node_name()
 5359            if tag == 'cluster':
 5360                obj.cluster = ClusterReader.read_one(reader)
 5361            elif tag == 'cpu_profile':
 5362                obj.cpu_profile = CpuProfileReader.read_one(reader)
 5363            elif tag == 'drivers_iso':
 5364                obj.drivers_iso = FileReader.read_one(reader)
 5365            elif tag == 'host':
 5366                obj.host = HostReader.read_one(reader)
 5367            elif tag == 'name':
 5368                obj.name = Reader.read_string(reader)
 5369            elif tag == 'password':
 5370                obj.password = Reader.read_string(reader)
 5371            elif tag == 'provider':
 5372                obj.provider = Reader.read_enum(types.ExternalVmProviderType, reader)
 5373            elif tag == 'quota':
 5374                obj.quota = QuotaReader.read_one(reader)
 5375            elif tag == 'sparse':
 5376                obj.sparse = Reader.read_boolean(reader)
 5377            elif tag == 'storage_domain':
 5378                obj.storage_domain = StorageDomainReader.read_one(reader)
 5379            elif tag == 'url':
 5380                obj.url = Reader.read_string(reader)
 5381            elif tag == 'username':
 5382                obj.username = Reader.read_string(reader)
 5383            elif tag == 'vm':
 5384                obj.vm = VmReader.read_one(reader)
 5385            else:
 5386                reader.next_element()
 5387        for link in links:
 5388            ExternalVmImportReader._process_link(link, obj)
 5389
 5390        # Discard the end tag:
 5391        reader.read()
 5392
 5393        return obj
 5394
 5395    @staticmethod
 5396    def read_many(reader):
 5397        # Do nothing if there aren't more tags:
 5398        objs = List()
 5399        if not reader.forward():
 5400            return objs
 5401
 5402        # Process the attributes:
 5403        objs.href = reader.get_attribute('href')
 5404
 5405        # Discard the start tag:
 5406        empty = reader.empty_element()
 5407        reader.read()
 5408        if empty:
 5409            return objs
 5410
 5411        # Process the inner elements:
 5412        while reader.forward():
 5413            objs.append(ExternalVmImportReader.read_one(reader))
 5414
 5415        # Discard the end tag:
 5416        reader.read()
 5417
 5418        return objs
 5419
 5420
 5421class FaultReader(Reader):
 5422
 5423    def __init__(self):
 5424        super(FaultReader, self).__init__()
 5425
 5426    @staticmethod
 5427    def read_one(reader):
 5428        # Do nothing if there aren't more tags:
 5429        if not reader.forward():
 5430            return None
 5431
 5432        # Create the object:
 5433        obj = types.Fault()
 5434
 5435        # Process the attributes:
 5436        obj.href = reader.get_attribute('href')
 5437
 5438        # Discard the start tag:
 5439        empty = reader.empty_element()
 5440        reader.read()
 5441        if empty:
 5442            return obj
 5443
 5444        # Process the inner elements:
 5445        links = []
 5446        while reader.forward():
 5447            tag = reader.node_name()
 5448            if tag == 'detail':
 5449                obj.detail = Reader.read_string(reader)
 5450            elif tag == 'reason':
 5451                obj.reason = Reader.read_string(reader)
 5452            else:
 5453                reader.next_element()
 5454        for link in links:
 5455            FaultReader._process_link(link, obj)
 5456
 5457        # Discard the end tag:
 5458        reader.read()
 5459
 5460        return obj
 5461
 5462    @staticmethod
 5463    def read_many(reader):
 5464        # Do nothing if there aren't more tags:
 5465        objs = List()
 5466        if not reader.forward():
 5467            return objs
 5468
 5469        # Process the attributes:
 5470        objs.href = reader.get_attribute('href')
 5471
 5472        # Discard the start tag:
 5473        empty = reader.empty_element()
 5474        reader.read()
 5475        if empty:
 5476            return objs
 5477
 5478        # Process the inner elements:
 5479        while reader.forward():
 5480            objs.append(FaultReader.read_one(reader))
 5481
 5482        # Discard the end tag:
 5483        reader.read()
 5484
 5485        return objs
 5486
 5487
 5488class FencingPolicyReader(Reader):
 5489
 5490    def __init__(self):
 5491        super(FencingPolicyReader, self).__init__()
 5492
 5493    @staticmethod
 5494    def read_one(reader):
 5495        # Do nothing if there aren't more tags:
 5496        if not reader.forward():
 5497            return None
 5498
 5499        # Create the object:
 5500        obj = types.FencingPolicy()
 5501
 5502        # Process the attributes:
 5503        obj.href = reader.get_attribute('href')
 5504
 5505        # Discard the start tag:
 5506        empty = reader.empty_element()
 5507        reader.read()
 5508        if empty:
 5509            return obj
 5510
 5511        # Process the inner elements:
 5512        links = []
 5513        while reader.forward():
 5514            tag = reader.node_name()
 5515            if tag == 'enabled':
 5516                obj.enabled = Reader.read_boolean(reader)
 5517            elif tag == 'skip_if_connectivity_broken':
 5518                obj.skip_if_connectivity_broken = SkipIfConnectivityBrokenReader.read_one(reader)
 5519            elif tag == 'skip_if_gluster_bricks_up':
 5520                obj.skip_if_gluster_bricks_up = Reader.read_boolean(reader)
 5521            elif tag == 'skip_if_gluster_quorum_not_met':
 5522                obj.skip_if_gluster_quorum_not_met = Reader.read_boolean(reader)
 5523            elif tag == 'skip_if_sd_active':
 5524                obj.skip_if_sd_active = SkipIfSdActiveReader.read_one(reader)
 5525            else:
 5526                reader.next_element()
 5527        for link in links:
 5528            FencingPolicyReader._process_link(link, obj)
 5529
 5530        # Discard the end tag:
 5531        reader.read()
 5532
 5533        return obj
 5534
 5535    @staticmethod
 5536    def read_many(reader):
 5537        # Do nothing if there aren't more tags:
 5538        objs = List()
 5539        if not reader.forward():
 5540            return objs
 5541
 5542        # Process the attributes:
 5543        objs.href = reader.get_attribute('href')
 5544
 5545        # Discard the start tag:
 5546        empty = reader.empty_element()
 5547        reader.read()
 5548        if empty:
 5549            return objs
 5550
 5551        # Process the inner elements:
 5552        while reader.forward():
 5553            objs.append(FencingPolicyReader.read_one(reader))
 5554
 5555        # Discard the end tag:
 5556        reader.read()
 5557
 5558        return objs
 5559
 5560
 5561class FileReader(Reader):
 5562
 5563    def __init__(self):
 5564        super(FileReader, self).__init__()
 5565
 5566    @staticmethod
 5567    def read_one(reader):
 5568        # Do nothing if there aren't more tags:
 5569        if not reader.forward():
 5570            return None
 5571
 5572        # Create the object:
 5573        obj = types.File()
 5574
 5575        # Process the attributes:
 5576        obj.href = reader.get_attribute('href')
 5577        value = reader.get_attribute('id')
 5578        if value is not None:
 5579            obj.id = value
 5580
 5581        # Discard the start tag:
 5582        empty = reader.empty_element()
 5583        reader.read()
 5584        if empty:
 5585            return obj
 5586
 5587        # Process the inner elements:
 5588        links = []
 5589        while reader.forward():
 5590            tag = reader.node_name()
 5591            if tag == 'comment':
 5592                obj.comment = Reader.read_string(reader)
 5593            elif tag == 'content':
 5594                obj.content = Reader.read_string(reader)
 5595            elif tag == 'description':
 5596                obj.description = Reader.read_string(reader)
 5597            elif tag == 'name':
 5598                obj.name = Reader.read_string(reader)
 5599            elif tag == 'storage_domain':
 5600                obj.storage_domain = StorageDomainReader.read_one(reader)
 5601            elif tag == 'type':
 5602                obj.type = Reader.read_string(reader)
 5603            else:
 5604                reader.next_element()
 5605        for link in links:
 5606            FileReader._process_link(link, obj)
 5607
 5608        # Discard the end tag:
 5609        reader.read()
 5610
 5611        return obj
 5612
 5613    @staticmethod
 5614    def read_many(reader):
 5615        # Do nothing if there aren't more tags:
 5616        objs = List()
 5617        if not reader.forward():
 5618            return objs
 5619
 5620        # Process the attributes:
 5621        objs.href = reader.get_attribute('href')
 5622
 5623        # Discard the start tag:
 5624        empty = reader.empty_element()
 5625        reader.read()
 5626        if empty:
 5627            return objs
 5628
 5629        # Process the inner elements:
 5630        while reader.forward():
 5631            objs.append(FileReader.read_one(reader))
 5632
 5633        # Discard the end tag:
 5634        reader.read()
 5635
 5636        return objs
 5637
 5638
 5639class FilterReader(Reader):
 5640
 5641    def __init__(self):
 5642        super(FilterReader, self).__init__()
 5643
 5644    @staticmethod
 5645    def read_one(reader):
 5646        # Do nothing if there aren't more tags:
 5647        if not reader.forward():
 5648            return None
 5649
 5650        # Create the object:
 5651        obj = types.Filter()
 5652
 5653        # Process the attributes:
 5654        obj.href = reader.get_attribute('href')
 5655        value = reader.get_attribute('id')
 5656        if value is not None:
 5657            obj.id = value
 5658
 5659        # Discard the start tag:
 5660        empty = reader.empty_element()
 5661        reader.read()
 5662        if empty:
 5663            return obj
 5664
 5665        # Process the inner elements:
 5666        links = []
 5667        while reader.forward():
 5668            tag = reader.node_name()
 5669            if tag == 'comment':
 5670                obj.comment = Reader.read_string(reader)
 5671            elif tag == 'description':
 5672                obj.description = Reader.read_string(reader)
 5673            elif tag == 'name':
 5674                obj.name = Reader.read_string(reader)
 5675            elif tag == 'position':
 5676                obj.position = Reader.read_integer(reader)
 5677            elif tag == 'scheduling_policy_unit':
 5678                obj.scheduling_policy_unit = SchedulingPolicyUnitReader.read_one(reader)
 5679            else:
 5680                reader.next_element()
 5681        for link in links:
 5682            FilterReader._process_link(link, obj)
 5683
 5684        # Discard the end tag:
 5685        reader.read()
 5686
 5687        return obj
 5688
 5689    @staticmethod
 5690    def read_many(reader):
 5691        # Do nothing if there aren't more tags:
 5692        objs = List()
 5693        if not reader.forward():
 5694            return objs
 5695
 5696        # Process the attributes:
 5697        objs.href = reader.get_attribute('href')
 5698
 5699        # Discard the start tag:
 5700        empty = reader.empty_element()
 5701        reader.read()
 5702        if empty:
 5703            return objs
 5704
 5705        # Process the inner elements:
 5706        while reader.forward():
 5707            objs.append(FilterReader.read_one(reader))
 5708
 5709        # Discard the end tag:
 5710        reader.read()
 5711
 5712        return objs
 5713
 5714
 5715class FloppyReader(Reader):
 5716
 5717    def __init__(self):
 5718        super(FloppyReader, self).__init__()
 5719
 5720    @staticmethod
 5721    def read_one(reader):
 5722        # Do nothing if there aren't more tags:
 5723        if not reader.forward():
 5724            return None
 5725
 5726        # Create the object:
 5727        obj = types.Floppy()
 5728
 5729        # Process the attributes:
 5730        obj.href = reader.get_attribute('href')
 5731        value = reader.get_attribute('id')
 5732        if value is not None:
 5733            obj.id = value
 5734
 5735        # Discard the start tag:
 5736        empty = reader.empty_element()
 5737        reader.read()
 5738        if empty:
 5739            return obj
 5740
 5741        # Process the inner elements:
 5742        links = []
 5743        while reader.forward():
 5744            tag = reader.node_name()
 5745            if tag == 'comment':
 5746                obj.comment = Reader.read_string(reader)
 5747            elif tag == 'description':
 5748                obj.description = Reader.read_string(reader)
 5749            elif tag == 'file':
 5750                obj.file = FileReader.read_one(reader)
 5751            elif tag == 'instance_type':
 5752                obj.instance_type = InstanceTypeReader.read_one(reader)
 5753            elif tag == 'name':
 5754                obj.name = Reader.read_string(reader)
 5755            elif tag == 'template':
 5756                obj.template = TemplateReader.read_one(reader)
 5757            elif tag == 'vm':
 5758                obj.vm = VmReader.read_one(reader)
 5759            elif tag == 'vms':
 5760                obj.vms = VmReader.read_many(reader)
 5761            elif tag == 'link':
 5762                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 5763                reader.next_element()
 5764            else:
 5765                reader.next_element()
 5766        for link in links:
 5767            FloppyReader._process_link(link, obj)
 5768
 5769        # Discard the end tag:
 5770        reader.read()
 5771
 5772        return obj
 5773
 5774    @staticmethod
 5775    def read_many(reader):
 5776        # Do nothing if there aren't more tags:
 5777        objs = List()
 5778        if not reader.forward():
 5779            return objs
 5780
 5781        # Process the attributes:
 5782        objs.href = reader.get_attribute('href')
 5783
 5784        # Discard the start tag:
 5785        empty = reader.empty_element()
 5786        reader.read()
 5787        if empty:
 5788            return objs
 5789
 5790        # Process the inner elements:
 5791        while reader.forward():
 5792            objs.append(FloppyReader.read_one(reader))
 5793
 5794        # Discard the end tag:
 5795        reader.read()
 5796
 5797        return objs
 5798
 5799    @staticmethod
 5800    def _process_link(link, obj):
 5801        # Process the attributes:
 5802        rel = link[0]
 5803        href = link[1]
 5804        if href and rel:
 5805            if rel == "vms":
 5806                if obj.vms is not None:
 5807                    obj.vms.href = href
 5808                else:
 5809                    obj.vms = List(href)
 5810
 5811
 5812class FopStatisticReader(Reader):
 5813
 5814    def __init__(self):
 5815        super(FopStatisticReader, self).__init__()
 5816
 5817    @staticmethod
 5818    def read_one(reader):
 5819        # Do nothing if there aren't more tags:
 5820        if not reader.forward():
 5821            return None
 5822
 5823        # Create the object:
 5824        obj = types.FopStatistic()
 5825
 5826        # Process the attributes:
 5827        obj.href = reader.get_attribute('href')
 5828
 5829        # Discard the start tag:
 5830        empty = reader.empty_element()
 5831        reader.read()
 5832        if empty:
 5833            return obj
 5834
 5835        # Process the inner elements:
 5836        links = []
 5837        while reader.forward():
 5838            tag = reader.node_name()
 5839            if tag == 'name':
 5840                obj.name = Reader.read_string(reader)
 5841            elif tag == 'statistics':
 5842                obj.statistics = StatisticReader.read_many(reader)
 5843            else:
 5844                reader.next_element()
 5845        for link in links:
 5846            FopStatisticReader._process_link(link, obj)
 5847
 5848        # Discard the end tag:
 5849        reader.read()
 5850
 5851        return obj
 5852
 5853    @staticmethod
 5854    def read_many(reader):
 5855        # Do nothing if there aren't more tags:
 5856        objs = List()
 5857        if not reader.forward():
 5858            return objs
 5859
 5860        # Process the attributes:
 5861        objs.href = reader.get_attribute('href')
 5862
 5863        # Discard the start tag:
 5864        empty = reader.empty_element()
 5865        reader.read()
 5866        if empty:
 5867            return objs
 5868
 5869        # Process the inner elements:
 5870        while reader.forward():
 5871            objs.append(FopStatisticReader.read_one(reader))
 5872
 5873        # Discard the end tag:
 5874        reader.read()
 5875
 5876        return objs
 5877
 5878
 5879class GlusterBrickReader(Reader):
 5880
 5881    def __init__(self):
 5882        super(GlusterBrickReader, self).__init__()
 5883
 5884    @staticmethod
 5885    def read_one(reader):
 5886        # Do nothing if there aren't more tags:
 5887        if not reader.forward():
 5888            return None
 5889
 5890        # Create the object:
 5891        obj = types.GlusterBrick()
 5892
 5893        # Process the attributes:
 5894        obj.href = reader.get_attribute('href')
 5895        value = reader.get_attribute('id')
 5896        if value is not None:
 5897            obj.id = value
 5898
 5899        # Discard the start tag:
 5900        empty = reader.empty_element()
 5901        reader.read()
 5902        if empty:
 5903            return obj
 5904
 5905        # Process the inner elements:
 5906        links = []
 5907        while reader.forward():
 5908            tag = reader.node_name()
 5909            if tag == 'brick_dir':
 5910                obj.brick_dir = Reader.read_string(reader)
 5911            elif tag == 'comment':
 5912                obj.comment = Reader.read_string(reader)
 5913            elif tag == 'description':
 5914                obj.description = Reader.read_string(reader)
 5915            elif tag == 'device':
 5916                obj.device = Reader.read_string(reader)
 5917            elif tag == 'fs_name':
 5918                obj.fs_name = Reader.read_string(reader)
 5919            elif tag == 'gluster_clients':
 5920                obj.gluster_clients = GlusterClientReader.read_many(reader)
 5921            elif tag == 'gluster_volume':
 5922                obj.gluster_volume = GlusterVolumeReader.read_one(reader)
 5923            elif tag == 'instance_type':
 5924                obj.instance_type = InstanceTypeReader.read_one(reader)
 5925            elif tag == 'memory_pools':
 5926                obj.memory_pools = GlusterMemoryPoolReader.read_many(reader)
 5927            elif tag == 'mnt_options':
 5928                obj.mnt_options = Reader.read_string(reader)
 5929            elif tag == 'name':
 5930                obj.name = Reader.read_string(reader)
 5931            elif tag == 'pid':
 5932                obj.pid = Reader.read_integer(reader)
 5933            elif tag == 'port':
 5934                obj.port = Reader.read_integer(reader)
 5935            elif tag == 'server_id':
 5936                obj.server_id = Reader.read_string(reader)
 5937            elif tag == 'statistics':
 5938                obj.statistics = StatisticReader.read_many(reader)
 5939            elif tag == 'status':
 5940                obj.status = Reader.read_enum(types.GlusterBrickStatus, reader)
 5941            elif tag == 'template':
 5942                obj.template = TemplateReader.read_one(reader)
 5943            elif tag == 'vm':
 5944                obj.vm = VmReader.read_one(reader)
 5945            elif tag == 'vms':
 5946                obj.vms = VmReader.read_many(reader)
 5947            elif tag == 'link':
 5948                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 5949                reader.next_element()
 5950            else:
 5951                reader.next_element()
 5952        for link in links:
 5953            GlusterBrickReader._process_link(link, obj)
 5954
 5955        # Discard the end tag:
 5956        reader.read()
 5957
 5958        return obj
 5959
 5960    @staticmethod
 5961    def read_many(reader):
 5962        # Do nothing if there aren't more tags:
 5963        objs = List()
 5964        if not reader.forward():
 5965            return objs
 5966
 5967        # Process the attributes:
 5968        objs.href = reader.get_attribute('href')
 5969
 5970        # Discard the start tag:
 5971        empty = reader.empty_element()
 5972        reader.read()
 5973        if empty:
 5974            return objs
 5975
 5976        # Process the inner elements:
 5977        while reader.forward():
 5978            objs.append(GlusterBrickReader.read_one(reader))
 5979
 5980        # Discard the end tag:
 5981        reader.read()
 5982
 5983        return objs
 5984
 5985    @staticmethod
 5986    def _process_link(link, obj):
 5987        # Process the attributes:
 5988        rel = link[0]
 5989        href = link[1]
 5990        if href and rel:
 5991            if rel == "statistics":
 5992                if obj.statistics is not None:
 5993                    obj.statistics.href = href
 5994                else:
 5995                    obj.statistics = List(href)
 5996            elif rel == "vms":
 5997                if obj.vms is not None:
 5998                    obj.vms.href = href
 5999                else:
 6000                    obj.vms = List(href)
 6001
 6002
 6003class GlusterBrickAdvancedDetailsReader(Reader):
 6004
 6005    def __init__(self):
 6006        super(GlusterBrickAdvancedDetailsReader, self).__init__()
 6007
 6008    @staticmethod
 6009    def read_one(reader):
 6010        # Do nothing if there aren't more tags:
 6011        if not reader.forward():
 6012            return None
 6013
 6014        # Create the object:
 6015        obj = types.GlusterBrickAdvancedDetails()
 6016
 6017        # Process the attributes:
 6018        obj.href = reader.get_attribute('href')
 6019        value = reader.get_attribute('id')
 6020        if value is not None:
 6021            obj.id = value
 6022
 6023        # Discard the start tag:
 6024        empty = reader.empty_element()
 6025        reader.read()
 6026        if empty:
 6027            return obj
 6028
 6029        # Process the inner elements:
 6030        links = []
 6031        while reader.forward():
 6032            tag = reader.node_name()
 6033            if tag == 'comment':
 6034                obj.comment = Reader.read_string(reader)
 6035            elif tag == 'description':
 6036                obj.description = Reader.read_string(reader)
 6037            elif tag == 'device':
 6038                obj.device = Reader.read_string(reader)
 6039            elif tag == 'fs_name':
 6040                obj.fs_name = Reader.read_string(reader)
 6041            elif tag == 'gluster_clients':
 6042                obj.gluster_clients = GlusterClientReader.read_many(reader)
 6043            elif tag == 'instance_type':
 6044                obj.instance_type = InstanceTypeReader.read_one(reader)
 6045            elif tag == 'memory_pools':
 6046                obj.memory_pools = GlusterMemoryPoolReader.read_many(reader)
 6047            elif tag == 'mnt_options':
 6048                obj.mnt_options = Reader.read_string(reader)
 6049            elif tag == 'name':
 6050                obj.name = Reader.read_string(reader)
 6051            elif tag == 'pid':
 6052                obj.pid = Reader.read_integer(reader)
 6053            elif tag == 'port':
 6054                obj.port = Reader.read_integer(reader)
 6055            elif tag == 'template':
 6056                obj.template = TemplateReader.read_one(reader)
 6057            elif tag == 'vm':
 6058                obj.vm = VmReader.read_one(reader)
 6059            elif tag == 'vms':
 6060                obj.vms = VmReader.read_many(reader)
 6061            elif tag == 'link':
 6062                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 6063                reader.next_element()
 6064            else:
 6065                reader.next_element()
 6066        for link in links:
 6067            GlusterBrickAdvancedDetailsReader._process_link(link, obj)
 6068
 6069        # Discard the end tag:
 6070        reader.read()
 6071
 6072        return obj
 6073
 6074    @staticmethod
 6075    def read_many(reader):
 6076        # Do nothing if there aren't more tags:
 6077        objs = List()
 6078        if not reader.forward():
 6079            return objs
 6080
 6081        # Process the attributes:
 6082        objs.href = reader.get_attribute('href')
 6083
 6084        # Discard the start tag:
 6085        empty = reader.empty_element()
 6086        reader.read()
 6087        if empty:
 6088            return objs
 6089
 6090        # Process the inner elements:
 6091        while reader.forward():
 6092            objs.append(GlusterBrickAdvancedDetailsReader.read_one(reader))
 6093
 6094        # Discard the end tag:
 6095        reader.read()
 6096
 6097        return objs
 6098
 6099    @staticmethod
 6100    def _process_link(link, obj):
 6101        # Process the attributes:
 6102        rel = link[0]
 6103        href = link[1]
 6104        if href and rel:
 6105            if rel == "vms":
 6106                if obj.vms is not None:
 6107                    obj.vms.href = href
 6108                else:
 6109                    obj.vms = List(href)
 6110
 6111
 6112class GlusterBrickMemoryInfoReader(Reader):
 6113
 6114    def __init__(self):
 6115        super(GlusterBrickMemoryInfoReader, self).__init__()
 6116
 6117    @staticmethod
 6118    def read_one(reader):
 6119        # Do nothing if there aren't more tags:
 6120        if not reader.forward():
 6121            return None
 6122
 6123        # Create the object:
 6124        obj = types.GlusterBrickMemoryInfo()
 6125
 6126        # Process the attributes:
 6127        obj.href = reader.get_attribute('href')
 6128
 6129        # Discard the start tag:
 6130        empty = reader.empty_element()
 6131        reader.read()
 6132        if empty:
 6133            return obj
 6134
 6135        # Process the inner elements:
 6136        links = []
 6137        while reader.forward():
 6138            tag = reader.node_name()
 6139            if tag == 'memory_pools':
 6140                obj.memory_pools = GlusterMemoryPoolReader.read_many(reader)
 6141            else:
 6142                reader.next_element()
 6143        for link in links:
 6144            GlusterBrickMemoryInfoReader._process_link(link, obj)
 6145
 6146        # Discard the end tag:
 6147        reader.read()
 6148
 6149        return obj
 6150
 6151    @staticmethod
 6152    def read_many(reader):
 6153        # Do nothing if there aren't more tags:
 6154        objs = List()
 6155        if not reader.forward():
 6156            return objs
 6157
 6158        # Process the attributes:
 6159        objs.href = reader.get_attribute('href')
 6160
 6161        # Discard the start tag:
 6162        empty = reader.empty_element()
 6163        reader.read()
 6164        if empty:
 6165            return objs
 6166
 6167        # Process the inner elements:
 6168        while reader.forward():
 6169            objs.append(GlusterBrickMemoryInfoReader.read_one(reader))
 6170
 6171        # Discard the end tag:
 6172        reader.read()
 6173
 6174        return objs
 6175
 6176
 6177class GlusterClientReader(Reader):
 6178
 6179    def __init__(self):
 6180        super(GlusterClientReader, self).__init__()
 6181
 6182    @staticmethod
 6183    def read_one(reader):
 6184        # Do nothing if there aren't more tags:
 6185        if not reader.forward():
 6186            return None
 6187
 6188        # Create the object:
 6189        obj = types.GlusterClient()
 6190
 6191        # Process the attributes:
 6192        obj.href = reader.get_attribute('href')
 6193
 6194        # Discard the start tag:
 6195        empty = reader.empty_element()
 6196        reader.read()
 6197        if empty:
 6198            return obj
 6199
 6200        # Process the inner elements:
 6201        links = []
 6202        while reader.forward():
 6203            tag = reader.node_name()
 6204            if tag == 'bytes_read':
 6205                obj.bytes_read = Reader.read_integer(reader)
 6206            elif tag == 'bytes_written':
 6207                obj.bytes_written = Reader.read_integer(reader)
 6208            elif tag == 'client_port':
 6209                obj.client_port = Reader.read_integer(reader)
 6210            elif tag == 'host_name':
 6211                obj.host_name = Reader.read_string(reader)
 6212            else:
 6213                reader.next_element()
 6214        for link in links:
 6215            GlusterClientReader._process_link(link, obj)
 6216
 6217        # Discard the end tag:
 6218        reader.read()
 6219
 6220        return obj
 6221
 6222    @staticmethod
 6223    def read_many(reader):
 6224        # Do nothing if there aren't more tags:
 6225        objs = List()
 6226        if not reader.forward():
 6227            return objs
 6228
 6229        # Process the attributes:
 6230        objs.href = reader.get_attribute('href')
 6231
 6232        # Discard the start tag:
 6233        empty = reader.empty_element()
 6234        reader.read()
 6235        if empty:
 6236            return objs
 6237
 6238        # Process the inner elements:
 6239        while reader.forward():
 6240            objs.append(GlusterClientReader.read_one(reader))
 6241
 6242        # Discard the end tag:
 6243        reader.read()
 6244
 6245        return objs
 6246
 6247
 6248class GlusterHookReader(Reader):
 6249
 6250    def __init__(self):
 6251        super(GlusterHookReader, self).__init__()
 6252
 6253    @staticmethod
 6254    def read_one(reader):
 6255        # Do nothing if there aren't more tags:
 6256        if not reader.forward():
 6257            return None
 6258
 6259        # Create the object:
 6260        obj = types.GlusterHook()
 6261
 6262        # Process the attributes:
 6263        obj.href = reader.get_attribute('href')
 6264        value = reader.get_attribute('id')
 6265        if value is not None:
 6266            obj.id = value
 6267
 6268        # Discard the start tag:
 6269        empty = reader.empty_element()
 6270        reader.read()
 6271        if empty:
 6272            return obj
 6273
 6274        # Process the inner elements:
 6275        links = []
 6276        while reader.forward():
 6277            tag = reader.node_name()
 6278            if tag == 'checksum':
 6279                obj.checksum = Reader.read_string(reader)
 6280            elif tag == 'cluster':
 6281                obj.cluster = ClusterReader.read_one(reader)
 6282            elif tag == 'comment':
 6283                obj.comment = Reader.read_string(reader)
 6284            elif tag == 'conflict_status':
 6285                obj.conflict_status = Reader.read_integer(reader)
 6286            elif tag == 'conflicts':
 6287                obj.conflicts = Reader.read_string(reader)
 6288            elif tag == 'content':
 6289                obj.content = Reader.read_string(reader)
 6290            elif tag == 'content_type':
 6291                obj.content_type = Reader.read_enum(types.HookContentType, reader)
 6292            elif tag == 'description':
 6293                obj.description = Reader.read_string(reader)
 6294            elif tag == 'gluster_command':
 6295                obj.gluster_command = Reader.read_string(reader)
 6296            elif tag == 'name':
 6297                obj.name = Reader.read_string(reader)
 6298            elif tag == 'server_hooks':
 6299                obj.server_hooks = GlusterServerHookReader.read_many(reader)
 6300            elif tag == 'stage':
 6301                obj.stage = Reader.read_enum(types.HookStage, reader)
 6302            elif tag == 'status':
 6303                obj.status = Reader.read_enum(types.GlusterHookStatus, reader)
 6304            elif tag == 'link':
 6305                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 6306                reader.next_element()
 6307            else:
 6308                reader.next_element()
 6309        for link in links:
 6310            GlusterHookReader._process_link(link, obj)
 6311
 6312        # Discard the end tag:
 6313        reader.read()
 6314
 6315        return obj
 6316
 6317    @staticmethod
 6318    def read_many(reader):
 6319        # Do nothing if there aren't more tags:
 6320        objs = List()
 6321        if not reader.forward():
 6322            return objs
 6323
 6324        # Process the attributes:
 6325        objs.href = reader.get_attribute('href')
 6326
 6327        # Discard the start tag:
 6328        empty = reader.empty_element()
 6329        reader.read()
 6330        if empty:
 6331            return objs
 6332
 6333        # Process the inner elements:
 6334        while reader.forward():
 6335            objs.append(GlusterHookReader.read_one(reader))
 6336
 6337        # Discard the end tag:
 6338        reader.read()
 6339
 6340        return objs
 6341
 6342    @staticmethod
 6343    def _process_link(link, obj):
 6344        # Process the attributes:
 6345        rel = link[0]
 6346        href = link[1]
 6347        if href and rel:
 6348            if rel == "serverhooks":
 6349                if obj.server_hooks is not None:
 6350                    obj.server_hooks.href = href
 6351                else:
 6352                    obj.server_hooks = List(href)
 6353
 6354
 6355class GlusterMemoryPoolReader(Reader):
 6356
 6357    def __init__(self):
 6358        super(GlusterMemoryPoolReader, self).__init__()
 6359
 6360    @staticmethod
 6361    def read_one(reader):
 6362        # Do nothing if there aren't more tags:
 6363        if not reader.forward():
 6364            return None
 6365
 6366        # Create the object:
 6367        obj = types.GlusterMemoryPool()
 6368
 6369        # Process the attributes:
 6370        obj.href = reader.get_attribute('href')
 6371        value = reader.get_attribute('id')
 6372        if value is not None:
 6373            obj.id = value
 6374
 6375        # Discard the start tag:
 6376        empty = reader.empty_element()
 6377        reader.read()
 6378        if empty:
 6379            return obj
 6380
 6381        # Process the inner elements:
 6382        links = []
 6383        while reader.forward():
 6384            tag = reader.node_name()
 6385            if tag == 'alloc_count':
 6386                obj.alloc_count = Reader.read_integer(reader)
 6387            elif tag == 'cold_count':
 6388                obj.cold_count = Reader.read_integer(reader)
 6389            elif tag == 'comment':
 6390                obj.comment = Reader.read_string(reader)
 6391            elif tag == 'description':
 6392                obj.description = Reader.read_string(reader)
 6393            elif tag == 'hot_count':
 6394                obj.hot_count = Reader.read_integer(reader)
 6395            elif tag == 'max_alloc':
 6396                obj.max_alloc = Reader.read_integer(reader)
 6397            elif tag == 'max_stdalloc':
 6398                obj.max_stdalloc = Reader.read_integer(reader)
 6399            elif tag == 'name':
 6400                obj.name = Reader.read_string(reader)
 6401            elif tag == 'padded_size':
 6402                obj.padded_size = Reader.read_integer(reader)
 6403            elif tag == 'pool_misses':
 6404                obj.pool_misses = Reader.read_integer(reader)
 6405            elif tag == 'type':
 6406                obj.type = Reader.read_string(reader)
 6407            else:
 6408                reader.next_element()
 6409        for link in links:
 6410            GlusterMemoryPoolReader._process_link(link, obj)
 6411
 6412        # Discard the end tag:
 6413        reader.read()
 6414
 6415        return obj
 6416
 6417    @staticmethod
 6418    def read_many(reader):
 6419        # Do nothing if there aren't more tags:
 6420        objs = List()
 6421        if not reader.forward():
 6422            return objs
 6423
 6424        # Process the attributes:
 6425        objs.href = reader.get_attribute('href')
 6426
 6427        # Discard the start tag:
 6428        empty = reader.empty_element()
 6429        reader.read()
 6430        if empty:
 6431            return objs
 6432
 6433        # Process the inner elements:
 6434        while reader.forward():
 6435            objs.append(GlusterMemoryPoolReader.read_one(reader))
 6436
 6437        # Discard the end tag:
 6438        reader.read()
 6439
 6440        return objs
 6441
 6442
 6443class GlusterServerHookReader(Reader):
 6444
 6445    def __init__(self):
 6446        super(GlusterServerHookReader, self).__init__()
 6447
 6448    @staticmethod
 6449    def read_one(reader):
 6450        # Do nothing if there aren't more tags:
 6451        if not reader.forward():
 6452            return None
 6453
 6454        # Create the object:
 6455        obj = types.GlusterServerHook()
 6456
 6457        # Process the attributes:
 6458        obj.href = reader.get_attribute('href')
 6459        value = reader.get_attribute('id')
 6460        if value is not None:
 6461            obj.id = value
 6462
 6463        # Discard the start tag:
 6464        empty = reader.empty_element()
 6465        reader.read()
 6466        if empty:
 6467            return obj
 6468
 6469        # Process the inner elements:
 6470        links = []
 6471        while reader.forward():
 6472            tag = reader.node_name()
 6473            if tag == 'checksum':
 6474                obj.checksum = Reader.read_string(reader)
 6475            elif tag == 'comment':
 6476                obj.comment = Reader.read_string(reader)
 6477            elif tag == 'content_type':
 6478                obj.content_type = Reader.read_enum(types.HookContentType, reader)
 6479            elif tag == 'description':
 6480                obj.description = Reader.read_string(reader)
 6481            elif tag == 'host':
 6482                obj.host = HostReader.read_one(reader)
 6483            elif tag == 'name':
 6484                obj.name = Reader.read_string(reader)
 6485            elif tag == 'status':
 6486                obj.status = Reader.read_enum(types.GlusterHookStatus, reader)
 6487            else:
 6488                reader.next_element()
 6489        for link in links:
 6490            GlusterServerHookReader._process_link(link, obj)
 6491
 6492        # Discard the end tag:
 6493        reader.read()
 6494
 6495        return obj
 6496
 6497    @staticmethod
 6498    def read_many(reader):
 6499        # Do nothing if there aren't more tags:
 6500        objs = List()
 6501        if not reader.forward():
 6502            return objs
 6503
 6504        # Process the attributes:
 6505        objs.href = reader.get_attribute('href')
 6506
 6507        # Discard the start tag:
 6508        empty = reader.empty_element()
 6509        reader.read()
 6510        if empty:
 6511            return objs
 6512
 6513        # Process the inner elements:
 6514        while reader.forward():
 6515            objs.append(GlusterServerHookReader.read_one(reader))
 6516
 6517        # Discard the end tag:
 6518        reader.read()
 6519
 6520        return objs
 6521
 6522
 6523class GlusterVolumeReader(Reader):
 6524
 6525    def __init__(self):
 6526        super(GlusterVolumeReader, self).__init__()
 6527
 6528    @staticmethod
 6529    def read_one(reader):
 6530        # Do nothing if there aren't more tags:
 6531        if not reader.forward():
 6532            return None
 6533
 6534        # Create the object:
 6535        obj = types.GlusterVolume()
 6536
 6537        # Process the attributes:
 6538        obj.href = reader.get_attribute('href')
 6539        value = reader.get_attribute('id')
 6540        if value is not None:
 6541            obj.id = value
 6542
 6543        # Discard the start tag:
 6544        empty = reader.empty_element()
 6545        reader.read()
 6546        if empty:
 6547            return obj
 6548
 6549        # Process the inner elements:
 6550        links = []
 6551        while reader.forward():
 6552            tag = reader.node_name()
 6553            if tag == 'bricks':
 6554                obj.bricks = GlusterBrickReader.read_many(reader)
 6555            elif tag == 'cluster':
 6556                obj.cluster = ClusterReader.read_one(reader)
 6557            elif tag == 'comment':
 6558                obj.comment = Reader.read_string(reader)
 6559            elif tag == 'description':
 6560                obj.description = Reader.read_string(reader)
 6561            elif tag == 'disperse_count':
 6562                obj.disperse_count = Reader.read_integer(reader)
 6563            elif tag == 'name':
 6564                obj.name = Reader.read_string(reader)
 6565            elif tag == 'options':
 6566                obj.options = OptionReader.read_many(reader)
 6567            elif tag == 'redundancy_count':
 6568                obj.redundancy_count = Reader.read_integer(reader)
 6569            elif tag == 'replica_count':
 6570                obj.replica_count = Reader.read_integer(reader)
 6571            elif tag == 'statistics':
 6572                obj.statistics = StatisticReader.read_many(reader)
 6573            elif tag == 'status':
 6574                obj.status = Reader.read_enum(types.GlusterVolumeStatus, reader)
 6575            elif tag == 'stripe_count':
 6576                obj.stripe_count = Reader.read_integer(reader)
 6577            elif tag == 'transport_types':
 6578                obj.transport_types = Reader.read_enums(types.TransportType, reader)
 6579            elif tag == 'volume_type':
 6580                obj.volume_type = Reader.read_enum(types.GlusterVolumeType, reader)
 6581            elif tag == 'link':
 6582                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 6583                reader.next_element()
 6584            else:
 6585                reader.next_element()
 6586        for link in links:
 6587            GlusterVolumeReader._process_link(link, obj)
 6588
 6589        # Discard the end tag:
 6590        reader.read()
 6591
 6592        return obj
 6593
 6594    @staticmethod
 6595    def read_many(reader):
 6596        # Do nothing if there aren't more tags:
 6597        objs = List()
 6598        if not reader.forward():
 6599            return objs
 6600
 6601        # Process the attributes:
 6602        objs.href = reader.get_attribute('href')
 6603
 6604        # Discard the start tag:
 6605        empty = reader.empty_element()
 6606        reader.read()
 6607        if empty:
 6608            return objs
 6609
 6610        # Process the inner elements:
 6611        while reader.forward():
 6612            objs.append(GlusterVolumeReader.read_one(reader))
 6613
 6614        # Discard the end tag:
 6615        reader.read()
 6616
 6617        return objs
 6618
 6619    @staticmethod
 6620    def _process_link(link, obj):
 6621        # Process the attributes:
 6622        rel = link[0]
 6623        href = link[1]
 6624        if href and rel:
 6625            if rel == "bricks":
 6626                if obj.bricks is not None:
 6627                    obj.bricks.href = href
 6628                else:
 6629                    obj.bricks = List(href)
 6630            elif rel == "statistics":
 6631                if obj.statistics is not None:
 6632                    obj.statistics.href = href
 6633                else:
 6634                    obj.statistics = List(href)
 6635
 6636
 6637class GlusterVolumeProfileDetailsReader(Reader):
 6638
 6639    def __init__(self):
 6640        super(GlusterVolumeProfileDetailsReader, self).__init__()
 6641
 6642    @staticmethod
 6643    def read_one(reader):
 6644        # Do nothing if there aren't more tags:
 6645        if not reader.forward():
 6646            return None
 6647
 6648        # Create the object:
 6649        obj = types.GlusterVolumeProfileDetails()
 6650
 6651        # Process the attributes:
 6652        obj.href = reader.get_attribute('href')
 6653        value = reader.get_attribute('id')
 6654        if value is not None:
 6655            obj.id = value
 6656
 6657        # Discard the start tag:
 6658        empty = reader.empty_element()
 6659        reader.read()
 6660        if empty:
 6661            return obj
 6662
 6663        # Process the inner elements:
 6664        links = []
 6665        while reader.forward():
 6666            tag = reader.node_name()
 6667            if tag == 'brick_profile_details':
 6668                obj.brick_profile_details = BrickProfileDetailReader.read_many(reader)
 6669            elif tag == 'comment':
 6670                obj.comment = Reader.read_string(reader)
 6671            elif tag == 'description':
 6672                obj.description = Reader.read_string(reader)
 6673            elif tag == 'name':
 6674                obj.name = Reader.read_string(reader)
 6675            elif tag == 'nfs_profile_details':
 6676                obj.nfs_profile_details = NfsProfileDetailReader.read_many(reader)
 6677            else:
 6678                reader.next_element()
 6679        for link in links:
 6680            GlusterVolumeProfileDetailsReader._process_link(link, obj)
 6681
 6682        # Discard the end tag:
 6683        reader.read()
 6684
 6685        return obj
 6686
 6687    @staticmethod
 6688    def read_many(reader):
 6689        # Do nothing if there aren't more tags:
 6690        objs = List()
 6691        if not reader.forward():
 6692            return objs
 6693
 6694        # Process the attributes:
 6695        objs.href = reader.get_attribute('href')
 6696
 6697        # Discard the start tag:
 6698        empty = reader.empty_element()
 6699        reader.read()
 6700        if empty:
 6701            return objs
 6702
 6703        # Process the inner elements:
 6704        while reader.forward():
 6705            objs.append(GlusterVolumeProfileDetailsReader.read_one(reader))
 6706
 6707        # Discard the end tag:
 6708        reader.read()
 6709
 6710        return objs
 6711
 6712
 6713class GracePeriodReader(Reader):
 6714
 6715    def __init__(self):
 6716        super(GracePeriodReader, self).__init__()
 6717
 6718    @staticmethod
 6719    def read_one(reader):
 6720        # Do nothing if there aren't more tags:
 6721        if not reader.forward():
 6722            return None
 6723
 6724        # Create the object:
 6725        obj = types.GracePeriod()
 6726
 6727        # Process the attributes:
 6728        obj.href = reader.get_attribute('href')
 6729
 6730        # Discard the start tag:
 6731        empty = reader.empty_element()
 6732        reader.read()
 6733        if empty:
 6734            return obj
 6735
 6736        # Process the inner elements:
 6737        links = []
 6738        while reader.forward():
 6739            tag = reader.node_name()
 6740            if tag == 'expiry':
 6741                obj.expiry = Reader.read_integer(reader)
 6742            else:
 6743                reader.next_element()
 6744        for link in links:
 6745            GracePeriodReader._process_link(link, obj)
 6746
 6747        # Discard the end tag:
 6748        reader.read()
 6749
 6750        return obj
 6751
 6752    @staticmethod
 6753    def read_many(reader):
 6754        # Do nothing if there aren't more tags:
 6755        objs = List()
 6756        if not reader.forward():
 6757            return objs
 6758
 6759        # Process the attributes:
 6760        objs.href = reader.get_attribute('href')
 6761
 6762        # Discard the start tag:
 6763        empty = reader.empty_element()
 6764        reader.read()
 6765        if empty:
 6766            return objs
 6767
 6768        # Process the inner elements:
 6769        while reader.forward():
 6770            objs.append(GracePeriodReader.read_one(reader))
 6771
 6772        # Discard the end tag:
 6773        reader.read()
 6774
 6775        return objs
 6776
 6777
 6778class GraphicsConsoleReader(Reader):
 6779
 6780    def __init__(self):
 6781        super(GraphicsConsoleReader, self).__init__()
 6782
 6783    @staticmethod
 6784    def read_one(reader):
 6785        # Do nothing if there aren't more tags:
 6786        if not reader.forward():
 6787            return None
 6788
 6789        # Create the object:
 6790        obj = types.GraphicsConsole()
 6791
 6792        # Process the attributes:
 6793        obj.href = reader.get_attribute('href')
 6794        value = reader.get_attribute('id')
 6795        if value is not None:
 6796            obj.id = value
 6797
 6798        # Discard the start tag:
 6799        empty = reader.empty_element()
 6800        reader.read()
 6801        if empty:
 6802            return obj
 6803
 6804        # Process the inner elements:
 6805        links = []
 6806        while reader.forward():
 6807            tag = reader.node_name()
 6808            if tag == 'address':
 6809                obj.address = Reader.read_string(reader)
 6810            elif tag == 'comment':
 6811                obj.comment = Reader.read_string(reader)
 6812            elif tag == 'description':
 6813                obj.description = Reader.read_string(reader)
 6814            elif tag == 'instance_type':
 6815                obj.instance_type = InstanceTypeReader.read_one(reader)
 6816            elif tag == 'name':
 6817                obj.name = Reader.read_string(reader)
 6818            elif tag == 'port':
 6819                obj.port = Reader.read_integer(reader)
 6820            elif tag == 'protocol':
 6821                obj.protocol = Reader.read_enum(types.GraphicsType, reader)
 6822            elif tag == 'template':
 6823                obj.template = TemplateReader.read_one(reader)
 6824            elif tag == 'tls_port':
 6825                obj.tls_port = Reader.read_integer(reader)
 6826            elif tag == 'vm':
 6827                obj.vm = VmReader.read_one(reader)
 6828            else:
 6829                reader.next_element()
 6830        for link in links:
 6831            GraphicsConsoleReader._process_link(link, obj)
 6832
 6833        # Discard the end tag:
 6834        reader.read()
 6835
 6836        return obj
 6837
 6838    @staticmethod
 6839    def read_many(reader):
 6840        # Do nothing if there aren't more tags:
 6841        objs = List()
 6842        if not reader.forward():
 6843            return objs
 6844
 6845        # Process the attributes:
 6846        objs.href = reader.get_attribute('href')
 6847
 6848        # Discard the start tag:
 6849        empty = reader.empty_element()
 6850        reader.read()
 6851        if empty:
 6852            return objs
 6853
 6854        # Process the inner elements:
 6855        while reader.forward():
 6856            objs.append(GraphicsConsoleReader.read_one(reader))
 6857
 6858        # Discard the end tag:
 6859        reader.read()
 6860
 6861        return objs
 6862
 6863
 6864class GroupReader(Reader):
 6865
 6866    def __init__(self):
 6867        super(GroupReader, self).__init__()
 6868
 6869    @staticmethod
 6870    def read_one(reader):
 6871        # Do nothing if there aren't more tags:
 6872        if not reader.forward():
 6873            return None
 6874
 6875        # Create the object:
 6876        obj = types.Group()
 6877
 6878        # Process the attributes:
 6879        obj.href = reader.get_attribute('href')
 6880        value = reader.get_attribute('id')
 6881        if value is not None:
 6882            obj.id = value
 6883
 6884        # Discard the start tag:
 6885        empty = reader.empty_element()
 6886        reader.read()
 6887        if empty:
 6888            return obj
 6889
 6890        # Process the inner elements:
 6891        links = []
 6892        while reader.forward():
 6893            tag = reader.node_name()
 6894            if tag == 'comment':
 6895                obj.comment = Reader.read_string(reader)
 6896            elif tag == 'description':
 6897                obj.description = Reader.read_string(reader)
 6898            elif tag == 'domain':
 6899                obj.domain = DomainReader.read_one(reader)
 6900            elif tag == 'domain_entry_id':
 6901                obj.domain_entry_id = Reader.read_string(reader)
 6902            elif tag == 'name':
 6903                obj.name = Reader.read_string(reader)
 6904            elif tag == 'namespace':
 6905                obj.namespace = Reader.read_string(reader)
 6906            elif tag == 'permissions':
 6907                obj.permissions = PermissionReader.read_many(reader)
 6908            elif tag == 'roles':
 6909                obj.roles = RoleReader.read_many(reader)
 6910            elif tag == 'tags':
 6911                obj.tags = TagReader.read_many(reader)
 6912            elif tag == 'link':
 6913                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 6914                reader.next_element()
 6915            else:
 6916                reader.next_element()
 6917        for link in links:
 6918            GroupReader._process_link(link, obj)
 6919
 6920        # Discard the end tag:
 6921        reader.read()
 6922
 6923        return obj
 6924
 6925    @staticmethod
 6926    def read_many(reader):
 6927        # Do nothing if there aren't more tags:
 6928        objs = List()
 6929        if not reader.forward():
 6930            return objs
 6931
 6932        # Process the attributes:
 6933        objs.href = reader.get_attribute('href')
 6934
 6935        # Discard the start tag:
 6936        empty = reader.empty_element()
 6937        reader.read()
 6938        if empty:
 6939            return objs
 6940
 6941        # Process the inner elements:
 6942        while reader.forward():
 6943            objs.append(GroupReader.read_one(reader))
 6944
 6945        # Discard the end tag:
 6946        reader.read()
 6947
 6948        return objs
 6949
 6950    @staticmethod
 6951    def _process_link(link, obj):
 6952        # Process the attributes:
 6953        rel = link[0]
 6954        href = link[1]
 6955        if href and rel:
 6956            if rel == "permissions":
 6957                if obj.permissions is not None:
 6958                    obj.permissions.href = href
 6959                else:
 6960                    obj.permissions = List(href)
 6961            elif rel == "roles":
 6962                if obj.roles is not None:
 6963                    obj.roles.href = href
 6964                else:
 6965                    obj.roles = List(href)
 6966            elif rel == "tags":
 6967                if obj.tags is not None:
 6968                    obj.tags.href = href
 6969                else:
 6970                    obj.tags = List(href)
 6971
 6972
 6973class GuestOperatingSystemReader(Reader):
 6974
 6975    def __init__(self):
 6976        super(GuestOperatingSystemReader, self).__init__()
 6977
 6978    @staticmethod
 6979    def read_one(reader):
 6980        # Do nothing if there aren't more tags:
 6981        if not reader.forward():
 6982            return None
 6983
 6984        # Create the object:
 6985        obj = types.GuestOperatingSystem()
 6986
 6987        # Process the attributes:
 6988        obj.href = reader.get_attribute('href')
 6989
 6990        # Discard the start tag:
 6991        empty = reader.empty_element()
 6992        reader.read()
 6993        if empty:
 6994            return obj
 6995
 6996        # Process the inner elements:
 6997        links = []
 6998        while reader.forward():
 6999            tag = reader.node_name()
 7000            if tag == 'architecture':
 7001                obj.architecture = Reader.read_string(reader)
 7002            elif tag == 'codename':
 7003                obj.codename = Reader.read_string(reader)
 7004            elif tag == 'distribution':
 7005                obj.distribution = Reader.read_string(reader)
 7006            elif tag == 'family':
 7007                obj.family = Reader.read_string(reader)
 7008            elif tag == 'kernel':
 7009                obj.kernel = KernelReader.read_one(reader)
 7010            elif tag == 'version':
 7011                obj.version = VersionReader.read_one(reader)
 7012            else:
 7013                reader.next_element()
 7014        for link in links:
 7015            GuestOperatingSystemReader._process_link(link, obj)
 7016
 7017        # Discard the end tag:
 7018        reader.read()
 7019
 7020        return obj
 7021
 7022    @staticmethod
 7023    def read_many(reader):
 7024        # Do nothing if there aren't more tags:
 7025        objs = List()
 7026        if not reader.forward():
 7027            return objs
 7028
 7029        # Process the attributes:
 7030        objs.href = reader.get_attribute('href')
 7031
 7032        # Discard the start tag:
 7033        empty = reader.empty_element()
 7034        reader.read()
 7035        if empty:
 7036            return objs
 7037
 7038        # Process the inner elements:
 7039        while reader.forward():
 7040            objs.append(GuestOperatingSystemReader.read_one(reader))
 7041
 7042        # Discard the end tag:
 7043        reader.read()
 7044
 7045        return objs
 7046
 7047
 7048class HardwareInformationReader(Reader):
 7049
 7050    def __init__(self):
 7051        super(HardwareInformationReader, self).__init__()
 7052
 7053    @staticmethod
 7054    def read_one(reader):
 7055        # Do nothing if there aren't more tags:
 7056        if not reader.forward():
 7057            return None
 7058
 7059        # Create the object:
 7060        obj = types.HardwareInformation()
 7061
 7062        # Process the attributes:
 7063        obj.href = reader.get_attribute('href')
 7064
 7065        # Discard the start tag:
 7066        empty = reader.empty_element()
 7067        reader.read()
 7068        if empty:
 7069            return obj
 7070
 7071        # Process the inner elements:
 7072        links = []
 7073        while reader.forward():
 7074            tag = reader.node_name()
 7075            if tag == 'family':
 7076                obj.family = Reader.read_string(reader)
 7077            elif tag == 'manufacturer':
 7078                obj.manufacturer = Reader.read_string(reader)
 7079            elif tag == 'product_name':
 7080                obj.product_name = Reader.read_string(reader)
 7081            elif tag == 'serial_number':
 7082                obj.serial_number = Reader.read_string(reader)
 7083            elif tag == 'supported_rng_sources':
 7084                obj.supported_rng_sources = Reader.read_enums(types.RngSource, reader)
 7085            elif tag == 'uuid':
 7086                obj.uuid = Reader.read_string(reader)
 7087            elif tag == 'version':
 7088                obj.version = Reader.read_string(reader)
 7089            else:
 7090                reader.next_element()
 7091        for link in links:
 7092            HardwareInformationReader._process_link(link, obj)
 7093
 7094        # Discard the end tag:
 7095        reader.read()
 7096
 7097        return obj
 7098
 7099    @staticmethod
 7100    def read_many(reader):
 7101        # Do nothing if there aren't more tags:
 7102        objs = List()
 7103        if not reader.forward():
 7104            return objs
 7105
 7106        # Process the attributes:
 7107        objs.href = reader.get_attribute('href')
 7108
 7109        # Discard the start tag:
 7110        empty = reader.empty_element()
 7111        reader.read()
 7112        if empty:
 7113            return objs
 7114
 7115        # Process the inner elements:
 7116        while reader.forward():
 7117            objs.append(HardwareInformationReader.read_one(reader))
 7118
 7119        # Discard the end tag:
 7120        reader.read()
 7121
 7122        return objs
 7123
 7124
 7125class HighAvailabilityReader(Reader):
 7126
 7127    def __init__(self):
 7128        super(HighAvailabilityReader, self).__init__()
 7129
 7130    @staticmethod
 7131    def read_one(reader):
 7132        # Do nothing if there aren't more tags:
 7133        if not reader.forward():
 7134            return None
 7135
 7136        # Create the object:
 7137        obj = types.HighAvailability()
 7138
 7139        # Process the attributes:
 7140        obj.href = reader.get_attribute('href')
 7141
 7142        # Discard the start tag:
 7143        empty = reader.empty_element()
 7144        reader.read()
 7145        if empty:
 7146            return obj
 7147
 7148        # Process the inner elements:
 7149        links = []
 7150        while reader.forward():
 7151            tag = reader.node_name()
 7152            if tag == 'enabled':
 7153                obj.enabled = Reader.read_boolean(reader)
 7154            elif tag == 'priority':
 7155                obj.priority = Reader.read_integer(reader)
 7156            else:
 7157                reader.next_element()
 7158        for link in links:
 7159            HighAvailabilityReader._process_link(link, obj)
 7160
 7161        # Discard the end tag:
 7162        reader.read()
 7163
 7164        return obj
 7165
 7166    @staticmethod
 7167    def read_many(reader):
 7168        # Do nothing if there aren't more tags:
 7169        objs = List()
 7170        if not reader.forward():
 7171            return objs
 7172
 7173        # Process the attributes:
 7174        objs.href = reader.get_attribute('href')
 7175
 7176        # Discard the start tag:
 7177        empty = reader.empty_element()
 7178        reader.read()
 7179        if empty:
 7180            return objs
 7181
 7182        # Process the inner elements:
 7183        while reader.forward():
 7184            objs.append(HighAvailabilityReader.read_one(reader))
 7185
 7186        # Discard the end tag:
 7187        reader.read()
 7188
 7189        return objs
 7190
 7191
 7192class HookReader(Reader):
 7193
 7194    def __init__(self):
 7195        super(HookReader, self).__init__()
 7196
 7197    @staticmethod
 7198    def read_one(reader):
 7199        # Do nothing if there aren't more tags:
 7200        if not reader.forward():
 7201            return None
 7202
 7203        # Create the object:
 7204        obj = types.Hook()
 7205
 7206        # Process the attributes:
 7207        obj.href = reader.get_attribute('href')
 7208        value = reader.get_attribute('id')
 7209        if value is not None:
 7210            obj.id = value
 7211
 7212        # Discard the start tag:
 7213        empty = reader.empty_element()
 7214        reader.read()
 7215        if empty:
 7216            return obj
 7217
 7218        # Process the inner elements:
 7219        links = []
 7220        while reader.forward():
 7221            tag = reader.node_name()
 7222            if tag == 'comment':
 7223                obj.comment = Reader.read_string(reader)
 7224            elif tag == 'description':
 7225                obj.description = Reader.read_string(reader)
 7226            elif tag == 'event_name':
 7227                obj.event_name = Reader.read_string(reader)
 7228            elif tag == 'host':
 7229                obj.host = HostReader.read_one(reader)
 7230            elif tag == 'md5':
 7231                obj.md5 = Reader.read_string(reader)
 7232            elif tag == 'name':
 7233                obj.name = Reader.read_string(reader)
 7234            else:
 7235                reader.next_element()
 7236        for link in links:
 7237            HookReader._process_link(link, obj)
 7238
 7239        # Discard the end tag:
 7240        reader.read()
 7241
 7242        return obj
 7243
 7244    @staticmethod
 7245    def read_many(reader):
 7246        # Do nothing if there aren't more tags:
 7247        objs = List()
 7248        if not reader.forward():
 7249            return objs
 7250
 7251        # Process the attributes:
 7252        objs.href = reader.get_attribute('href')
 7253
 7254        # Discard the start tag:
 7255        empty = reader.empty_element()
 7256        reader.read()
 7257        if empty:
 7258            return objs
 7259
 7260        # Process the inner elements:
 7261        while reader.forward():
 7262            objs.append(HookReader.read_one(reader))
 7263
 7264        # Discard the end tag:
 7265        reader.read()
 7266
 7267        return objs
 7268
 7269
 7270class HostReader(Reader):
 7271
 7272    def __init__(self):
 7273        super(HostReader, self).__init__()
 7274
 7275    @staticmethod
 7276    def read_one(reader):
 7277        # Do nothing if there aren't more tags:
 7278        if not reader.forward():
 7279            return None
 7280
 7281        # Create the object:
 7282        obj = types.Host()
 7283
 7284        # Process the attributes:
 7285        obj.href = reader.get_attribute('href')
 7286        value = reader.get_attribute('id')
 7287        if value is not None:
 7288            obj.id = value
 7289
 7290        # Discard the start tag:
 7291        empty = reader.empty_element()
 7292        reader.read()
 7293        if empty:
 7294            return obj
 7295
 7296        # Process the inner elements:
 7297        links = []
 7298        while reader.forward():
 7299            tag = reader.node_name()
 7300            if tag == 'address':
 7301                obj.address = Reader.read_string(reader)
 7302            elif tag == 'affinity_labels':
 7303                obj.affinity_labels = AffinityLabelReader.read_many(reader)
 7304            elif tag == 'agents':
 7305                obj.agents = AgentReader.read_many(reader)
 7306            elif tag == 'auto_numa_status':
 7307                obj.auto_numa_status = Reader.read_enum(types.AutoNumaStatus, reader)
 7308            elif tag == 'certificate':
 7309                obj.certificate = CertificateReader.read_one(reader)
 7310            elif tag == 'cluster':
 7311                obj.cluster = ClusterReader.read_one(reader)
 7312            elif tag == 'comment':
 7313                obj.comment = Reader.read_string(reader)
 7314            elif tag == 'cpu':
 7315                obj.cpu = CpuReader.read_one(reader)
 7316            elif tag == 'cpu_units':
 7317                obj.cpu_units = HostCpuUnitReader.read_many(reader)
 7318            elif tag == 'description':
 7319                obj.description = Reader.read_string(reader)
 7320            elif tag == 'device_passthrough':
 7321                obj.device_passthrough = HostDevicePassthroughReader.read_one(reader)
 7322            elif tag == 'devices':
 7323                obj.devices = HostDeviceReader.read_many(reader)
 7324            elif tag == 'display':
 7325                obj.display = DisplayReader.read_one(reader)
 7326            elif tag == 'external_host_provider':
 7327                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
 7328            elif tag == 'external_network_provider_configurations':
 7329                obj.external_network_provider_configurations = ExternalNetworkProviderConfigurationReader.read_many(reader)
 7330            elif tag == 'external_status':
 7331                obj.external_status = Reader.read_enum(types.ExternalStatus, reader)
 7332            elif tag == 'hardware_information':
 7333                obj.hardware_information = HardwareInformationReader.read_one(reader)
 7334            elif tag == 'hooks':
 7335                obj.hooks = HookReader.read_many(reader)
 7336            elif tag == 'hosted_engine':
 7337                obj.hosted_engine = HostedEngineReader.read_one(reader)
 7338            elif tag == 'iscsi':
 7339                obj.iscsi = IscsiDetailsReader.read_one(reader)
 7340            elif tag == 'katello_errata':
 7341                obj.katello_errata = KatelloErratumReader.read_many(reader)
 7342            elif tag == 'kdump_status':
 7343                obj.kdump_status = Reader.read_enum(types.KdumpStatus, reader)
 7344            elif tag == 'ksm':
 7345                obj.ksm = KsmReader.read_one(reader)
 7346            elif tag == 'libvirt_version':
 7347                obj.libvirt_version = VersionReader.read_one(reader)
 7348            elif tag == 'max_scheduling_memory':
 7349                obj.max_scheduling_memory = Reader.read_integer(reader)
 7350            elif tag == 'memory':
 7351                obj.memory = Reader.read_integer(reader)
 7352            elif tag == 'name':
 7353                obj.name = Reader.read_string(reader)
 7354            elif tag == 'network_attachments':
 7355                obj.network_attachments = NetworkAttachmentReader.read_many(reader)
 7356            elif tag == 'network_operation_in_progress':
 7357                obj.network_operation_in_progress = Reader.read_boolean(reader)
 7358            elif tag == 'nics':
 7359                obj.nics = HostNicReader.read_many(reader)
 7360            elif tag == 'host_numa_nodes':
 7361                obj.numa_nodes = NumaNodeReader.read_many(reader)
 7362            elif tag == 'numa_supported':
 7363                obj.numa_supported = Reader.read_boolean(reader)
 7364            elif tag == 'os':
 7365                obj.os = OperatingSystemReader.read_one(reader)
 7366            elif tag == 'override_iptables':
 7367                obj.override_iptables = Reader.read_boolean(reader)
 7368            elif tag == 'ovn_configured':
 7369                obj.ovn_configured = Reader.read_boolean(reader)
 7370            elif tag == 'permissions':
 7371                obj.permissions = PermissionReader.read_many(reader)
 7372            elif tag == 'port':
 7373                obj.port = Reader.read_integer(reader)
 7374            elif tag == 'power_management':
 7375                obj.power_management = PowerManagementReader.read_one(reader)
 7376            elif tag == 'protocol':
 7377                obj.protocol = Reader.read_enum(types.HostProtocol, reader)
 7378            elif tag == 'reinstallation_required':
 7379                obj.reinstallation_required = Reader.read_boolean(reader)
 7380            elif tag == 'root_password':
 7381                obj.root_password = Reader.read_string(reader)
 7382            elif tag == 'se_linux':
 7383                obj.se_linux = SeLinuxReader.read_one(reader)
 7384            elif tag == 'spm':
 7385                obj.spm = SpmReader.read_one(reader)
 7386            elif tag == 'ssh':
 7387                obj.ssh = SshReader.read_one(reader)
 7388            elif tag == 'statistics':
 7389                obj.statistics = StatisticReader.read_many(reader)
 7390            elif tag == 'status':
 7391                obj.status = Reader.read_enum(types.HostStatus, reader)
 7392            elif tag == 'status_detail':
 7393                obj.status_detail = Reader.read_string(reader)
 7394            elif tag == 'storage_connection_extensions':
 7395                obj.storage_connection_extensions = StorageConnectionExtensionReader.read_many(reader)
 7396            elif tag == 'storages':
 7397                obj.storages = HostStorageReader.read_many(reader)
 7398            elif tag == 'summary':
 7399                obj.summary = VmSummaryReader.read_one(reader)
 7400            elif tag == 'tags':
 7401                obj.tags = TagReader.read_many(reader)
 7402            elif tag == 'transparent_hugepages':
 7403                obj.transparent_huge_pages = TransparentHugePagesReader.read_one(reader)
 7404            elif tag == 'type':
 7405                obj.type = Reader.read_enum(types.HostType, reader)
 7406            elif tag == 'unmanaged_networks':
 7407                obj.unmanaged_networks = UnmanagedNetworkReader.read_many(reader)
 7408            elif tag == 'update_available':
 7409                obj.update_available = Reader.read_boolean(reader)
 7410            elif tag == 'version':
 7411                obj.version = VersionReader.read_one(reader)
 7412            elif tag == 'vgpu_placement':
 7413                obj.vgpu_placement = Reader.read_enum(types.VgpuPlacement, reader)
 7414            elif tag == 'link':
 7415                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 7416                reader.next_element()
 7417            else:
 7418                reader.next_element()
 7419        for link in links:
 7420            HostReader._process_link(link, obj)
 7421
 7422        # Discard the end tag:
 7423        reader.read()
 7424
 7425        return obj
 7426
 7427    @staticmethod
 7428    def read_many(reader):
 7429        # Do nothing if there aren't more tags:
 7430        objs = List()
 7431        if not reader.forward():
 7432            return objs
 7433
 7434        # Process the attributes:
 7435        objs.href = reader.get_attribute('href')
 7436
 7437        # Discard the start tag:
 7438        empty = reader.empty_element()
 7439        reader.read()
 7440        if empty:
 7441            return objs
 7442
 7443        # Process the inner elements:
 7444        while reader.forward():
 7445            objs.append(HostReader.read_one(reader))
 7446
 7447        # Discard the end tag:
 7448        reader.read()
 7449
 7450        return objs
 7451
 7452    @staticmethod
 7453    def _process_link(link, obj):
 7454        # Process the attributes:
 7455        rel = link[0]
 7456        href = link[1]
 7457        if href and rel:
 7458            if rel == "affinitylabels":
 7459                if obj.affinity_labels is not None:
 7460                    obj.affinity_labels.href = href
 7461                else:
 7462                    obj.affinity_labels = List(href)
 7463            elif rel == "agents":
 7464                if obj.agents is not None:
 7465                    obj.agents.href = href
 7466                else:
 7467                    obj.agents = List(href)
 7468            elif rel == "cpuunits":
 7469                if obj.cpu_units is not None:
 7470                    obj.cpu_units.href = href
 7471                else:
 7472                    obj.cpu_units = List(href)
 7473            elif rel == "devices":
 7474                if obj.devices is not None:
 7475                    obj.devices.href = href
 7476                else:
 7477                    obj.devices = List(href)
 7478            elif rel == "externalnetworkproviderconfigurations":
 7479                if obj.external_network_provider_configurations is not None:
 7480                    obj.external_network_provider_configurations.href = href
 7481                else:
 7482                    obj.external_network_provider_configurations = List(href)
 7483            elif rel == "hooks":
 7484                if obj.hooks is not None:
 7485                    obj.hooks.href = href
 7486                else:
 7487                    obj.hooks = List(href)
 7488            elif rel == "katelloerrata":
 7489                if obj.katello_errata is not None:
 7490                    obj.katello_errata.href = href
 7491                else:
 7492                    obj.katello_errata = List(href)
 7493            elif rel == "networkattachments":
 7494                if obj.network_attachments is not None:
 7495                    obj.network_attachments.href = href
 7496                else:
 7497                    obj.network_attachments = List(href)
 7498            elif rel == "nics":
 7499                if obj.nics is not None:
 7500                    obj.nics.href = href
 7501                else:
 7502                    obj.nics = List(href)
 7503            elif rel == "numanodes":
 7504                if obj.numa_nodes is not None:
 7505                    obj.numa_nodes.href = href
 7506                else:
 7507                    obj.numa_nodes = List(href)
 7508            elif rel == "permissions":
 7509                if obj.permissions is not None:
 7510                    obj.permissions.href = href
 7511                else:
 7512                    obj.permissions = List(href)
 7513            elif rel == "statistics":
 7514                if obj.statistics is not None:
 7515                    obj.statistics.href = href
 7516                else:
 7517                    obj.statistics = List(href)
 7518            elif rel == "storageconnectionextensions":
 7519                if obj.storage_connection_extensions is not None:
 7520                    obj.storage_connection_extensions.href = href
 7521                else:
 7522                    obj.storage_connection_extensions = List(href)
 7523            elif rel == "storages":
 7524                if obj.storages is not None:
 7525                    obj.storages.href = href
 7526                else:
 7527                    obj.storages = List(href)
 7528            elif rel == "tags":
 7529                if obj.tags is not None:
 7530                    obj.tags.href = href
 7531                else:
 7532                    obj.tags = List(href)
 7533            elif rel == "unmanagednetworks":
 7534                if obj.unmanaged_networks is not None:
 7535                    obj.unmanaged_networks.href = href
 7536                else:
 7537                    obj.unmanaged_networks = List(href)
 7538
 7539
 7540class HostCpuUnitReader(Reader):
 7541
 7542    def __init__(self):
 7543        super(HostCpuUnitReader, self).__init__()
 7544
 7545    @staticmethod
 7546    def read_one(reader):
 7547        # Do nothing if there aren't more tags:
 7548        if not reader.forward():
 7549            return None
 7550
 7551        # Create the object:
 7552        obj = types.HostCpuUnit()
 7553
 7554        # Process the attributes:
 7555        obj.href = reader.get_attribute('href')
 7556        value = reader.get_attribute('id')
 7557        if value is not None:
 7558            obj.id = value
 7559
 7560        # Discard the start tag:
 7561        empty = reader.empty_element()
 7562        reader.read()
 7563        if empty:
 7564            return obj
 7565
 7566        # Process the inner elements:
 7567        links = []
 7568        while reader.forward():
 7569            tag = reader.node_name()
 7570            if tag == 'comment':
 7571                obj.comment = Reader.read_string(reader)
 7572            elif tag == 'core_id':
 7573                obj.core_id = Reader.read_integer(reader)
 7574            elif tag == 'cpu_id':
 7575                obj.cpu_id = Reader.read_integer(reader)
 7576            elif tag == 'description':
 7577                obj.description = Reader.read_string(reader)
 7578            elif tag == 'name':
 7579                obj.name = Reader.read_string(reader)
 7580            elif tag == 'runs_vdsm':
 7581                obj.runs_vdsm = Reader.read_boolean(reader)
 7582            elif tag == 'socket_id':
 7583                obj.socket_id = Reader.read_integer(reader)
 7584            elif tag == 'vms':
 7585                obj.vms = VmReader.read_many(reader)
 7586            elif tag == 'link':
 7587                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 7588                reader.next_element()
 7589            else:
 7590                reader.next_element()
 7591        for link in links:
 7592            HostCpuUnitReader._process_link(link, obj)
 7593
 7594        # Discard the end tag:
 7595        reader.read()
 7596
 7597        return obj
 7598
 7599    @staticmethod
 7600    def read_many(reader):
 7601        # Do nothing if there aren't more tags:
 7602        objs = List()
 7603        if not reader.forward():
 7604            return objs
 7605
 7606        # Process the attributes:
 7607        objs.href = reader.get_attribute('href')
 7608
 7609        # Discard the start tag:
 7610        empty = reader.empty_element()
 7611        reader.read()
 7612        if empty:
 7613            return objs
 7614
 7615        # Process the inner elements:
 7616        while reader.forward():
 7617            objs.append(HostCpuUnitReader.read_one(reader))
 7618
 7619        # Discard the end tag:
 7620        reader.read()
 7621
 7622        return objs
 7623
 7624    @staticmethod
 7625    def _process_link(link, obj):
 7626        # Process the attributes:
 7627        rel = link[0]
 7628        href = link[1]
 7629        if href and rel:
 7630            if rel == "vms":
 7631                if obj.vms is not None:
 7632                    obj.vms.href = href
 7633                else:
 7634                    obj.vms = List(href)
 7635
 7636
 7637class HostDeviceReader(Reader):
 7638
 7639    def __init__(self):
 7640        super(HostDeviceReader, self).__init__()
 7641
 7642    @staticmethod
 7643    def read_one(reader):
 7644        # Do nothing if there aren't more tags:
 7645        if not reader.forward():
 7646            return None
 7647
 7648        # Create the object:
 7649        obj = types.HostDevice()
 7650
 7651        # Process the attributes:
 7652        obj.href = reader.get_attribute('href')
 7653        value = reader.get_attribute('id')
 7654        if value is not None:
 7655            obj.id = value
 7656
 7657        # Discard the start tag:
 7658        empty = reader.empty_element()
 7659        reader.read()
 7660        if empty:
 7661            return obj
 7662
 7663        # Process the inner elements:
 7664        links = []
 7665        while reader.forward():
 7666            tag = reader.node_name()
 7667            if tag == 'capability':
 7668                obj.capability = Reader.read_string(reader)
 7669            elif tag == 'comment':
 7670                obj.comment = Reader.read_string(reader)
 7671            elif tag == 'description':
 7672                obj.description = Reader.read_string(reader)
 7673            elif tag == 'driver':
 7674                obj.driver = Reader.read_string(reader)
 7675            elif tag == 'host':
 7676                obj.host = HostReader.read_one(reader)
 7677            elif tag == 'iommu_group':
 7678                obj.iommu_group = Reader.read_integer(reader)
 7679            elif tag == 'm_dev_types':
 7680                obj.m_dev_types = MDevTypeReader.read_many(reader)
 7681            elif tag == 'name':
 7682                obj.name = Reader.read_string(reader)
 7683            elif tag == 'parent_device':
 7684                obj.parent_device = HostDeviceReader.read_one(reader)
 7685            elif tag == 'physical_function':
 7686                obj.physical_function = HostDeviceReader.read_one(reader)
 7687            elif tag == 'placeholder':
 7688                obj.placeholder = Reader.read_boolean(reader)
 7689            elif tag == 'product':
 7690                obj.product = ProductReader.read_one(reader)
 7691            elif tag == 'vendor':
 7692                obj.vendor = VendorReader.read_one(reader)
 7693            elif tag == 'virtual_functions':
 7694                obj.virtual_functions = Reader.read_integer(reader)
 7695            elif tag == 'vm':
 7696                obj.vm = VmReader.read_one(reader)
 7697            else:
 7698                reader.next_element()
 7699        for link in links:
 7700            HostDeviceReader._process_link(link, obj)
 7701
 7702        # Discard the end tag:
 7703        reader.read()
 7704
 7705        return obj
 7706
 7707    @staticmethod
 7708    def read_many(reader):
 7709        # Do nothing if there aren't more tags:
 7710        objs = List()
 7711        if not reader.forward():
 7712            return objs
 7713
 7714        # Process the attributes:
 7715        objs.href = reader.get_attribute('href')
 7716
 7717        # Discard the start tag:
 7718        empty = reader.empty_element()
 7719        reader.read()
 7720        if empty:
 7721            return objs
 7722
 7723        # Process the inner elements:
 7724        while reader.forward():
 7725            objs.append(HostDeviceReader.read_one(reader))
 7726
 7727        # Discard the end tag:
 7728        reader.read()
 7729
 7730        return objs
 7731
 7732
 7733class HostDevicePassthroughReader(Reader):
 7734
 7735    def __init__(self):
 7736        super(HostDevicePassthroughReader, self).__init__()
 7737
 7738    @staticmethod
 7739    def read_one(reader):
 7740        # Do nothing if there aren't more tags:
 7741        if not reader.forward():
 7742            return None
 7743
 7744        # Create the object:
 7745        obj = types.HostDevicePassthrough()
 7746
 7747        # Process the attributes:
 7748        obj.href = reader.get_attribute('href')
 7749
 7750        # Discard the start tag:
 7751        empty = reader.empty_element()
 7752        reader.read()
 7753        if empty:
 7754            return obj
 7755
 7756        # Process the inner elements:
 7757        links = []
 7758        while reader.forward():
 7759            tag = reader.node_name()
 7760            if tag == 'enabled':
 7761                obj.enabled = Reader.read_boolean(reader)
 7762            else:
 7763                reader.next_element()
 7764        for link in links:
 7765            HostDevicePassthroughReader._process_link(link, obj)
 7766
 7767        # Discard the end tag:
 7768        reader.read()
 7769
 7770        return obj
 7771
 7772    @staticmethod
 7773    def read_many(reader):
 7774        # Do nothing if there aren't more tags:
 7775        objs = List()
 7776        if not reader.forward():
 7777            return objs
 7778
 7779        # Process the attributes:
 7780        objs.href = reader.get_attribute('href')
 7781
 7782        # Discard the start tag:
 7783        empty = reader.empty_element()
 7784        reader.read()
 7785        if empty:
 7786            return objs
 7787
 7788        # Process the inner elements:
 7789        while reader.forward():
 7790            objs.append(HostDevicePassthroughReader.read_one(reader))
 7791
 7792        # Discard the end tag:
 7793        reader.read()
 7794
 7795        return objs
 7796
 7797
 7798class HostNicReader(Reader):
 7799
 7800    def __init__(self):
 7801        super(HostNicReader, self).__init__()
 7802
 7803    @staticmethod
 7804    def read_one(reader):
 7805        # Do nothing if there aren't more tags:
 7806        if not reader.forward():
 7807            return None
 7808
 7809        # Create the object:
 7810        obj = types.HostNic()
 7811
 7812        # Process the attributes:
 7813        obj.href = reader.get_attribute('href')
 7814        value = reader.get_attribute('id')
 7815        if value is not None:
 7816            obj.id = value
 7817
 7818        # Discard the start tag:
 7819        empty = reader.empty_element()
 7820        reader.read()
 7821        if empty:
 7822            return obj
 7823
 7824        # Process the inner elements:
 7825        links = []
 7826        while reader.forward():
 7827            tag = reader.node_name()
 7828            if tag == 'ad_aggregator_id':
 7829                obj.ad_aggregator_id = Reader.read_integer(reader)
 7830            elif tag == 'base_interface':
 7831                obj.base_interface = Reader.read_string(reader)
 7832            elif tag == 'bonding':
 7833                obj.bonding = BondingReader.read_one(reader)
 7834            elif tag == 'boot_protocol':
 7835                obj.boot_protocol = Reader.read_enum(types.BootProtocol, reader)
 7836            elif tag == 'bridged':
 7837                obj.bridged = Reader.read_boolean(reader)
 7838            elif tag == 'check_connectivity':
 7839                obj.check_connectivity = Reader.read_boolean(reader)
 7840            elif tag == 'comment':
 7841                obj.comment = Reader.read_string(reader)
 7842            elif tag == 'custom_configuration':
 7843                obj.custom_configuration = Reader.read_boolean(reader)
 7844            elif tag == 'description':
 7845                obj.description = Reader.read_string(reader)
 7846            elif tag == 'host':
 7847                obj.host = HostReader.read_one(reader)
 7848            elif tag == 'ip':
 7849                obj.ip = IpReader.read_one(reader)
 7850            elif tag == 'ipv6':
 7851                obj.ipv6 = IpReader.read_one(reader)
 7852            elif tag == 'ipv6_boot_protocol':
 7853                obj.ipv6_boot_protocol = Reader.read_enum(types.BootProtocol, reader)
 7854            elif tag == 'mac':
 7855                obj.mac = MacReader.read_one(reader)
 7856            elif tag == 'mtu':
 7857                obj.mtu = Reader.read_integer(reader)
 7858            elif tag == 'name':
 7859                obj.name = Reader.read_string(reader)
 7860            elif tag == 'network':
 7861                obj.network = NetworkReader.read_one(reader)
 7862            elif tag == 'network_labels':
 7863                obj.network_labels = NetworkLabelReader.read_many(reader)
 7864            elif tag == 'override_configuration':
 7865                obj.override_configuration = Reader.read_boolean(reader)
 7866            elif tag == 'physical_function':
 7867                obj.physical_function = HostNicReader.read_one(reader)
 7868            elif tag == 'properties':
 7869                obj.properties = PropertyReader.read_many(reader)
 7870            elif tag == 'qos':
 7871                obj.qos = QosReader.read_one(reader)
 7872            elif tag == 'speed':
 7873                obj.speed = Reader.read_integer(reader)
 7874            elif tag == 'statistics':
 7875                obj.statistics = StatisticReader.read_many(reader)
 7876            elif tag == 'status':
 7877                obj.status = Reader.read_enum(types.NicStatus, reader)
 7878            elif tag == 'virtual_functions_configuration':
 7879                obj.virtual_functions_configuration = HostNicVirtualFunctionsConfigurationReader.read_one(reader)
 7880            elif tag == 'vlan':
 7881                obj.vlan = VlanReader.read_one(reader)
 7882            elif tag == 'link':
 7883                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 7884                reader.next_element()
 7885            else:
 7886                reader.next_element()
 7887        for link in links:
 7888            HostNicReader._process_link(link, obj)
 7889
 7890        # Discard the end tag:
 7891        reader.read()
 7892
 7893        return obj
 7894
 7895    @staticmethod
 7896    def read_many(reader):
 7897        # Do nothing if there aren't more tags:
 7898        objs = List()
 7899        if not reader.forward():
 7900            return objs
 7901
 7902        # Process the attributes:
 7903        objs.href = reader.get_attribute('href')
 7904
 7905        # Discard the start tag:
 7906        empty = reader.empty_element()
 7907        reader.read()
 7908        if empty:
 7909            return objs
 7910
 7911        # Process the inner elements:
 7912        while reader.forward():
 7913            objs.append(HostNicReader.read_one(reader))
 7914
 7915        # Discard the end tag:
 7916        reader.read()
 7917
 7918        return objs
 7919
 7920    @staticmethod
 7921    def _process_link(link, obj):
 7922        # Process the attributes:
 7923        rel = link[0]
 7924        href = link[1]
 7925        if href and rel:
 7926            if rel == "networklabels":
 7927                if obj.network_labels is not None:
 7928                    obj.network_labels.href = href
 7929                else:
 7930                    obj.network_labels = List(href)
 7931            elif rel == "statistics":
 7932                if obj.statistics is not None:
 7933                    obj.statistics.href = href
 7934                else:
 7935                    obj.statistics = List(href)
 7936
 7937
 7938class HostNicVirtualFunctionsConfigurationReader(Reader):
 7939
 7940    def __init__(self):
 7941        super(HostNicVirtualFunctionsConfigurationReader, self).__init__()
 7942
 7943    @staticmethod
 7944    def read_one(reader):
 7945        # Do nothing if there aren't more tags:
 7946        if not reader.forward():
 7947            return None
 7948
 7949        # Create the object:
 7950        obj = types.HostNicVirtualFunctionsConfiguration()
 7951
 7952        # Process the attributes:
 7953        obj.href = reader.get_attribute('href')
 7954
 7955        # Discard the start tag:
 7956        empty = reader.empty_element()
 7957        reader.read()
 7958        if empty:
 7959            return obj
 7960
 7961        # Process the inner elements:
 7962        links = []
 7963        while reader.forward():
 7964            tag = reader.node_name()
 7965            if tag == 'all_networks_allowed':
 7966                obj.all_networks_allowed = Reader.read_boolean(reader)
 7967            elif tag == 'max_number_of_virtual_functions':
 7968                obj.max_number_of_virtual_functions = Reader.read_integer(reader)
 7969            elif tag == 'number_of_virtual_functions':
 7970                obj.number_of_virtual_functions = Reader.read_integer(reader)
 7971            else:
 7972                reader.next_element()
 7973        for link in links:
 7974            HostNicVirtualFunctionsConfigurationReader._process_link(link, obj)
 7975
 7976        # Discard the end tag:
 7977        reader.read()
 7978
 7979        return obj
 7980
 7981    @staticmethod
 7982    def read_many(reader):
 7983        # Do nothing if there aren't more tags:
 7984        objs = List()
 7985        if not reader.forward():
 7986            return objs
 7987
 7988        # Process the attributes:
 7989        objs.href = reader.get_attribute('href')
 7990
 7991        # Discard the start tag:
 7992        empty = reader.empty_element()
 7993        reader.read()
 7994        if empty:
 7995            return objs
 7996
 7997        # Process the inner elements:
 7998        while reader.forward():
 7999            objs.append(HostNicVirtualFunctionsConfigurationReader.read_one(reader))
 8000
 8001        # Discard the end tag:
 8002        reader.read()
 8003
 8004        return objs
 8005
 8006
 8007class HostStorageReader(Reader):
 8008
 8009    def __init__(self):
 8010        super(HostStorageReader, self).__init__()
 8011
 8012    @staticmethod
 8013    def read_one(reader):
 8014        # Do nothing if there aren't more tags:
 8015        if not reader.forward():
 8016            return None
 8017
 8018        # Create the object:
 8019        obj = types.HostStorage()
 8020
 8021        # Process the attributes:
 8022        obj.href = reader.get_attribute('href')
 8023        value = reader.get_attribute('id')
 8024        if value is not None:
 8025            obj.id = value
 8026
 8027        # Discard the start tag:
 8028        empty = reader.empty_element()
 8029        reader.read()
 8030        if empty:
 8031            return obj
 8032
 8033        # Process the inner elements:
 8034        links = []
 8035        while reader.forward():
 8036            tag = reader.node_name()
 8037            if tag == 'address':
 8038                obj.address = Reader.read_string(reader)
 8039            elif tag == 'comment':
 8040                obj.comment = Reader.read_string(reader)
 8041            elif tag == 'description':
 8042                obj.description = Reader.read_string(reader)
 8043            elif tag == 'driver_options':
 8044                obj.driver_options = PropertyReader.read_many(reader)
 8045            elif tag == 'driver_sensitive_options':
 8046                obj.driver_sensitive_options = PropertyReader.read_many(reader)
 8047            elif tag == 'host':
 8048                obj.host = HostReader.read_one(reader)
 8049            elif tag == 'logical_units':
 8050                obj.logical_units = LogicalUnitReader.read_many(reader)
 8051            elif tag == 'mount_options':
 8052                obj.mount_options = Reader.read_string(reader)
 8053            elif tag == 'name':
 8054                obj.name = Reader.read_string(reader)
 8055            elif tag == 'nfs_retrans':
 8056                obj.nfs_retrans = Reader.read_integer(reader)
 8057            elif tag == 'nfs_timeo':
 8058                obj.nfs_timeo = Reader.read_integer(reader)
 8059            elif tag == 'nfs_version':
 8060                obj.nfs_version = Reader.read_enum(types.NfsVersion, reader)
 8061            elif tag == 'override_luns':
 8062                obj.override_luns = Reader.read_boolean(reader)
 8063            elif tag == 'password':
 8064                obj.password = Reader.read_string(reader)
 8065            elif tag == 'path':
 8066                obj.path = Reader.read_string(reader)
 8067            elif tag == 'port':
 8068                obj.port = Reader.read_integer(reader)
 8069            elif tag == 'portal':
 8070                obj.portal = Reader.read_string(reader)
 8071            elif tag == 'target':
 8072                obj.target = Reader.read_string(reader)
 8073            elif tag == 'type':
 8074                obj.type = Reader.read_enum(types.StorageType, reader)
 8075            elif tag == 'username':
 8076                obj.username = Reader.read_string(reader)
 8077            elif tag == 'vfs_type':
 8078                obj.vfs_type = Reader.read_string(reader)
 8079            elif tag == 'volume_group':
 8080                obj.volume_group = VolumeGroupReader.read_one(reader)
 8081            else:
 8082                reader.next_element()
 8083        for link in links:
 8084            HostStorageReader._process_link(link, obj)
 8085
 8086        # Discard the end tag:
 8087        reader.read()
 8088
 8089        return obj
 8090
 8091    @staticmethod
 8092    def read_many(reader):
 8093        # Do nothing if there aren't more tags:
 8094        objs = List()
 8095        if not reader.forward():
 8096            return objs
 8097
 8098        # Process the attributes:
 8099        objs.href = reader.get_attribute('href')
 8100
 8101        # Discard the start tag:
 8102        empty = reader.empty_element()
 8103        reader.read()
 8104        if empty:
 8105            return objs
 8106
 8107        # Process the inner elements:
 8108        while reader.forward():
 8109            objs.append(HostStorageReader.read_one(reader))
 8110
 8111        # Discard the end tag:
 8112        reader.read()
 8113
 8114        return objs
 8115
 8116
 8117class HostedEngineReader(Reader):
 8118
 8119    def __init__(self):
 8120        super(HostedEngineReader, self).__init__()
 8121
 8122    @staticmethod
 8123    def read_one(reader):
 8124        # Do nothing if there aren't more tags:
 8125        if not reader.forward():
 8126            return None
 8127
 8128        # Create the object:
 8129        obj = types.HostedEngine()
 8130
 8131        # Process the attributes:
 8132        obj.href = reader.get_attribute('href')
 8133
 8134        # Discard the start tag:
 8135        empty = reader.empty_element()
 8136        reader.read()
 8137        if empty:
 8138            return obj
 8139
 8140        # Process the inner elements:
 8141        links = []
 8142        while reader.forward():
 8143            tag = reader.node_name()
 8144            if tag == 'active':
 8145                obj.active = Reader.read_boolean(reader)
 8146            elif tag == 'configured':
 8147                obj.configured = Reader.read_boolean(reader)
 8148            elif tag == 'global_maintenance':
 8149                obj.global_maintenance = Reader.read_boolean(reader)
 8150            elif tag == 'local_maintenance':
 8151                obj.local_maintenance = Reader.read_boolean(reader)
 8152            elif tag == 'score':
 8153                obj.score = Reader.read_integer(reader)
 8154            else:
 8155                reader.next_element()
 8156        for link in links:
 8157            HostedEngineReader._process_link(link, obj)
 8158
 8159        # Discard the end tag:
 8160        reader.read()
 8161
 8162        return obj
 8163
 8164    @staticmethod
 8165    def read_many(reader):
 8166        # Do nothing if there aren't more tags:
 8167        objs = List()
 8168        if not reader.forward():
 8169            return objs
 8170
 8171        # Process the attributes:
 8172        objs.href = reader.get_attribute('href')
 8173
 8174        # Discard the start tag:
 8175        empty = reader.empty_element()
 8176        reader.read()
 8177        if empty:
 8178            return objs
 8179
 8180        # Process the inner elements:
 8181        while reader.forward():
 8182            objs.append(HostedEngineReader.read_one(reader))
 8183
 8184        # Discard the end tag:
 8185        reader.read()
 8186
 8187        return objs
 8188
 8189
 8190class IconReader(Reader):
 8191
 8192    def __init__(self):
 8193        super(IconReader, self).__init__()
 8194
 8195    @staticmethod
 8196    def read_one(reader):
 8197        # Do nothing if there aren't more tags:
 8198        if not reader.forward():
 8199            return None
 8200
 8201        # Create the object:
 8202        obj = types.Icon()
 8203
 8204        # Process the attributes:
 8205        obj.href = reader.get_attribute('href')
 8206        value = reader.get_attribute('id')
 8207        if value is not None:
 8208            obj.id = value
 8209
 8210        # Discard the start tag:
 8211        empty = reader.empty_element()
 8212        reader.read()
 8213        if empty:
 8214            return obj
 8215
 8216        # Process the inner elements:
 8217        links = []
 8218        while reader.forward():
 8219            tag = reader.node_name()
 8220            if tag == 'comment':
 8221                obj.comment = Reader.read_string(reader)
 8222            elif tag == 'data':
 8223                obj.data = Reader.read_string(reader)
 8224            elif tag == 'description':
 8225                obj.description = Reader.read_string(reader)
 8226            elif tag == 'media_type':
 8227                obj.media_type = Reader.read_string(reader)
 8228            elif tag == 'name':
 8229                obj.name = Reader.read_string(reader)
 8230            else:
 8231                reader.next_element()
 8232        for link in links:
 8233            IconReader._process_link(link, obj)
 8234
 8235        # Discard the end tag:
 8236        reader.read()
 8237
 8238        return obj
 8239
 8240    @staticmethod
 8241    def read_many(reader):
 8242        # Do nothing if there aren't more tags:
 8243        objs = List()
 8244        if not reader.forward():
 8245            return objs
 8246
 8247        # Process the attributes:
 8248        objs.href = reader.get_attribute('href')
 8249
 8250        # Discard the start tag:
 8251        empty = reader.empty_element()
 8252        reader.read()
 8253        if empty:
 8254            return objs
 8255
 8256        # Process the inner elements:
 8257        while reader.forward():
 8258            objs.append(IconReader.read_one(reader))
 8259
 8260        # Discard the end tag:
 8261        reader.read()
 8262
 8263        return objs
 8264
 8265
 8266class IdentifiedReader(Reader):
 8267
 8268    def __init__(self):
 8269        super(IdentifiedReader, self).__init__()
 8270
 8271    @staticmethod
 8272    def read_one(reader):
 8273        # Do nothing if there aren't more tags:
 8274        if not reader.forward():
 8275            return None
 8276
 8277        # Create the object:
 8278        obj = types.Identified()
 8279
 8280        # Process the attributes:
 8281        obj.href = reader.get_attribute('href')
 8282        value = reader.get_attribute('id')
 8283        if value is not None:
 8284            obj.id = value
 8285
 8286        # Discard the start tag:
 8287        empty = reader.empty_element()
 8288        reader.read()
 8289        if empty:
 8290            return obj
 8291
 8292        # Process the inner elements:
 8293        links = []
 8294        while reader.forward():
 8295            tag = reader.node_name()
 8296            if tag == 'comment':
 8297                obj.comment = Reader.read_string(reader)
 8298            elif tag == 'description':
 8299                obj.description = Reader.read_string(reader)
 8300            elif tag == 'name':
 8301                obj.name = Reader.read_string(reader)
 8302            else:
 8303                reader.next_element()
 8304        for link in links:
 8305            IdentifiedReader._process_link(link, obj)
 8306
 8307        # Discard the end tag:
 8308        reader.read()
 8309
 8310        return obj
 8311
 8312    @staticmethod
 8313    def read_many(reader):
 8314        # Do nothing if there aren't more tags:
 8315        objs = List()
 8316        if not reader.forward():
 8317            return objs
 8318
 8319        # Process the attributes:
 8320        objs.href = reader.get_attribute('href')
 8321
 8322        # Discard the start tag:
 8323        empty = reader.empty_element()
 8324        reader.read()
 8325        if empty:
 8326            return objs
 8327
 8328        # Process the inner elements:
 8329        while reader.forward():
 8330            objs.append(IdentifiedReader.read_one(reader))
 8331
 8332        # Discard the end tag:
 8333        reader.read()
 8334
 8335        return objs
 8336
 8337
 8338class ImageReader(Reader):
 8339
 8340    def __init__(self):
 8341        super(ImageReader, self).__init__()
 8342
 8343    @staticmethod
 8344    def read_one(reader):
 8345        # Do nothing if there aren't more tags:
 8346        if not reader.forward():
 8347            return None
 8348
 8349        # Create the object:
 8350        obj = types.Image()
 8351
 8352        # Process the attributes:
 8353        obj.href = reader.get_attribute('href')
 8354        value = reader.get_attribute('id')
 8355        if value is not None:
 8356            obj.id = value
 8357
 8358        # Discard the start tag:
 8359        empty = reader.empty_element()
 8360        reader.read()
 8361        if empty:
 8362            return obj
 8363
 8364        # Process the inner elements:
 8365        links = []
 8366        while reader.forward():
 8367            tag = reader.node_name()
 8368            if tag == 'comment':
 8369                obj.comment = Reader.read_string(reader)
 8370            elif tag == 'description':
 8371                obj.description = Reader.read_string(reader)
 8372            elif tag == 'name':
 8373                obj.name = Reader.read_string(reader)
 8374            elif tag == 'size':
 8375                obj.size = Reader.read_integer(reader)
 8376            elif tag == 'storage_domain':
 8377                obj.storage_domain = StorageDomainReader.read_one(reader)
 8378            elif tag == 'type':
 8379                obj.type = Reader.read_enum(types.ImageFileType, reader)
 8380            else:
 8381                reader.next_element()
 8382        for link in links:
 8383            ImageReader._process_link(link, obj)
 8384
 8385        # Discard the end tag:
 8386        reader.read()
 8387
 8388        return obj
 8389
 8390    @staticmethod
 8391    def read_many(reader):
 8392        # Do nothing if there aren't more tags:
 8393        objs = List()
 8394        if not reader.forward():
 8395            return objs
 8396
 8397        # Process the attributes:
 8398        objs.href = reader.get_attribute('href')
 8399
 8400        # Discard the start tag:
 8401        empty = reader.empty_element()
 8402        reader.read()
 8403        if empty:
 8404            return objs
 8405
 8406        # Process the inner elements:
 8407        while reader.forward():
 8408            objs.append(ImageReader.read_one(reader))
 8409
 8410        # Discard the end tag:
 8411        reader.read()
 8412
 8413        return objs
 8414
 8415
 8416class ImageTransferReader(Reader):
 8417
 8418    def __init__(self):
 8419        super(ImageTransferReader, self).__init__()
 8420
 8421    @staticmethod
 8422    def read_one(reader):
 8423        # Do nothing if there aren't more tags:
 8424        if not reader.forward():
 8425            return None
 8426
 8427        # Create the object:
 8428        obj = types.ImageTransfer()
 8429
 8430        # Process the attributes:
 8431        obj.href = reader.get_attribute('href')
 8432        value = reader.get_attribute('id')
 8433        if value is not None:
 8434            obj.id = value
 8435
 8436        # Discard the start tag:
 8437        empty = reader.empty_element()
 8438        reader.read()
 8439        if empty:
 8440            return obj
 8441
 8442        # Process the inner elements:
 8443        links = []
 8444        while reader.forward():
 8445            tag = reader.node_name()
 8446            if tag == 'active':
 8447                obj.active = Reader.read_boolean(reader)
 8448            elif tag == 'backup':
 8449                obj.backup = BackupReader.read_one(reader)
 8450            elif tag == 'comment':
 8451                obj.comment = Reader.read_string(reader)
 8452            elif tag == 'description':
 8453                obj.description = Reader.read_string(reader)
 8454            elif tag == 'direction':
 8455                obj.direction = Reader.read_enum(types.ImageTransferDirection, reader)
 8456            elif tag == 'disk':
 8457                obj.disk = DiskReader.read_one(reader)
 8458            elif tag == 'format':
 8459                obj.format = Reader.read_enum(types.DiskFormat, reader)
 8460            elif tag == 'host':
 8461                obj.host = HostReader.read_one(reader)
 8462            elif tag == 'image':
 8463                obj.image = ImageReader.read_one(reader)
 8464            elif tag == 'inactivity_timeout':
 8465                obj.inactivity_timeout = Reader.read_integer(reader)
 8466            elif tag == 'name':
 8467                obj.name = Reader.read_string(reader)
 8468            elif tag == 'phase':
 8469                obj.phase = Reader.read_enum(types.ImageTransferPhase, reader)
 8470            elif tag == 'proxy_url':
 8471                obj.proxy_url = Reader.read_string(reader)
 8472            elif tag == 'shallow':
 8473                obj.shallow = Reader.read_boolean(reader)
 8474            elif tag == 'snapshot':
 8475                obj.snapshot = DiskSnapshotReader.read_one(reader)
 8476            elif tag == 'timeout_policy':
 8477                obj.timeout_policy = Reader.read_enum(types.ImageTransferTimeoutPolicy, reader)
 8478            elif tag == 'transfer_url':
 8479                obj.transfer_url = Reader.read_string(reader)
 8480            elif tag == 'transferred':
 8481                obj.transferred = Reader.read_integer(reader)
 8482            else:
 8483                reader.next_element()
 8484        for link in links:
 8485            ImageTransferReader._process_link(link, obj)
 8486
 8487        # Discard the end tag:
 8488        reader.read()
 8489
 8490        return obj
 8491
 8492    @staticmethod
 8493    def read_many(reader):
 8494        # Do nothing if there aren't more tags:
 8495        objs = List()
 8496        if not reader.forward():
 8497            return objs
 8498
 8499        # Process the attributes:
 8500        objs.href = reader.get_attribute('href')
 8501
 8502        # Discard the start tag:
 8503        empty = reader.empty_element()
 8504        reader.read()
 8505        if empty:
 8506            return objs
 8507
 8508        # Process the inner elements:
 8509        while reader.forward():
 8510            objs.append(ImageTransferReader.read_one(reader))
 8511
 8512        # Discard the end tag:
 8513        reader.read()
 8514
 8515        return objs
 8516
 8517
 8518class InitializationReader(Reader):
 8519
 8520    def __init__(self):
 8521        super(InitializationReader, self).__init__()
 8522
 8523    @staticmethod
 8524    def read_one(reader):
 8525        # Do nothing if there aren't more tags:
 8526        if not reader.forward():
 8527            return None
 8528
 8529        # Create the object:
 8530        obj = types.Initialization()
 8531
 8532        # Process the attributes:
 8533        obj.href = reader.get_attribute('href')
 8534
 8535        # Discard the start tag:
 8536        empty = reader.empty_element()
 8537        reader.read()
 8538        if empty:
 8539            return obj
 8540
 8541        # Process the inner elements:
 8542        links = []
 8543        while reader.forward():
 8544            tag = reader.node_name()
 8545            if tag == 'active_directory_ou':
 8546                obj.active_directory_ou = Reader.read_string(reader)
 8547            elif tag == 'authorized_ssh_keys':
 8548                obj.authorized_ssh_keys = Reader.read_string(reader)
 8549            elif tag == 'cloud_init':
 8550                obj.cloud_init = CloudInitReader.read_one(reader)
 8551            elif tag == 'cloud_init_network_protocol':
 8552                obj.cloud_init_network_protocol = Reader.read_enum(types.CloudInitNetworkProtocol, reader)
 8553            elif tag == 'configuration':
 8554                obj.configuration = ConfigurationReader.read_one(reader)
 8555            elif tag == 'custom_script':
 8556                obj.custom_script = Reader.read_string(reader)
 8557            elif tag == 'dns_search':
 8558                obj.dns_search = Reader.read_string(reader)
 8559            elif tag == 'dns_servers':
 8560                obj.dns_servers = Reader.read_string(reader)
 8561            elif tag == 'domain':
 8562                obj.domain = Reader.read_string(reader)
 8563            elif tag == 'host_name':
 8564                obj.host_name = Reader.read_string(reader)
 8565            elif tag == 'input_locale':
 8566                obj.input_locale = Reader.read_string(reader)
 8567            elif tag == 'nic_configurations':
 8568                obj.nic_configurations = NicConfigurationReader.read_many(reader)
 8569            elif tag == 'org_name':
 8570                obj.org_name = Reader.read_string(reader)
 8571            elif tag == 'regenerate_ids':
 8572                obj.regenerate_ids = Reader.read_boolean(reader)
 8573            elif tag == 'regenerate_ssh_keys':
 8574                obj.regenerate_ssh_keys = Reader.read_boolean(reader)
 8575            elif tag == 'root_password':
 8576                obj.root_password = Reader.read_string(reader)
 8577            elif tag == 'system_locale':
 8578                obj.system_locale = Reader.read_string(reader)
 8579            elif tag == 'timezone':
 8580                obj.timezone = Reader.read_string(reader)
 8581            elif tag == 'ui_language':
 8582                obj.ui_language = Reader.read_string(reader)
 8583            elif tag == 'user_locale':
 8584                obj.user_locale = Reader.read_string(reader)
 8585            elif tag == 'user_name':
 8586                obj.user_name = Reader.read_string(reader)
 8587            elif tag == 'windows_license_key':
 8588                obj.windows_license_key = Reader.read_string(reader)
 8589            else:
 8590                reader.next_element()
 8591        for link in links:
 8592            InitializationReader._process_link(link, obj)
 8593
 8594        # Discard the end tag:
 8595        reader.read()
 8596
 8597        return obj
 8598
 8599    @staticmethod
 8600    def read_many(reader):
 8601        # Do nothing if there aren't more tags:
 8602        objs = List()
 8603        if not reader.forward():
 8604            return objs
 8605
 8606        # Process the attributes:
 8607        objs.href = reader.get_attribute('href')
 8608
 8609        # Discard the start tag:
 8610        empty = reader.empty_element()
 8611        reader.read()
 8612        if empty:
 8613            return objs
 8614
 8615        # Process the inner elements:
 8616        while reader.forward():
 8617            objs.append(InitializationReader.read_one(reader))
 8618
 8619        # Discard the end tag:
 8620        reader.read()
 8621
 8622        return objs
 8623
 8624
 8625class InstanceTypeReader(Reader):
 8626
 8627    def __init__(self):
 8628        super(InstanceTypeReader, self).__init__()
 8629
 8630    @staticmethod
 8631    def read_one(reader):
 8632        # Do nothing if there aren't more tags:
 8633        if not reader.forward():
 8634            return None
 8635
 8636        # Create the object:
 8637        obj = types.InstanceType()
 8638
 8639        # Process the attributes:
 8640        obj.href = reader.get_attribute('href')
 8641        value = reader.get_attribute('id')
 8642        if value is not None:
 8643            obj.id = value
 8644
 8645        # Discard the start tag:
 8646        empty = reader.empty_element()
 8647        reader.read()
 8648        if empty:
 8649            return obj
 8650
 8651        # Process the inner elements:
 8652        links = []
 8653        while reader.forward():
 8654            tag = reader.node_name()
 8655            if tag == 'auto_pinning_policy':
 8656                obj.auto_pinning_policy = Reader.read_enum(types.AutoPinningPolicy, reader)
 8657            elif tag == 'bios':
 8658                obj.bios = BiosReader.read_one(reader)
 8659            elif tag == 'cdroms':
 8660                obj.cdroms = CdromReader.read_many(reader)
 8661            elif tag == 'cluster':
 8662                obj.cluster = ClusterReader.read_one(reader)
 8663            elif tag == 'comment':
 8664                obj.comment = Reader.read_string(reader)
 8665            elif tag == 'console':
 8666                obj.console = ConsoleReader.read_one(reader)
 8667            elif tag == 'cpu':
 8668                obj.cpu = CpuReader.read_one(reader)
 8669            elif tag == 'cpu_pinning_policy':
 8670                obj.cpu_pinning_policy = Reader.read_enum(types.CpuPinningPolicy, reader)
 8671            elif tag == 'cpu_profile':
 8672                obj.cpu_profile = CpuProfileReader.read_one(reader)
 8673            elif tag == 'cpu_shares':
 8674                obj.cpu_shares = Reader.read_integer(reader)
 8675            elif tag == 'creation_time':
 8676                obj.creation_time = Reader.read_date(reader)
 8677            elif tag == 'custom_compatibility_version':
 8678                obj.custom_compatibility_version = VersionReader.read_one(reader)
 8679            elif tag == 'custom_cpu_model':
 8680                obj.custom_cpu_model = Reader.read_string(reader)
 8681            elif tag == 'custom_emulated_machine':
 8682                obj.custom_emulated_machine = Reader.read_string(reader)
 8683            elif tag == 'custom_properties':
 8684                obj.custom_properties = CustomPropertyReader.read_many(reader)
 8685            elif tag == 'delete_protected':
 8686                obj.delete_protected = Reader.read_boolean(reader)
 8687            elif tag == 'description':
 8688                obj.description = Reader.read_string(reader)
 8689            elif tag == 'disk_attachments':
 8690                obj.disk_attachments = DiskAttachmentReader.read_many(reader)
 8691            elif tag == 'display':
 8692                obj.display = DisplayReader.read_one(reader)
 8693            elif tag == 'domain':
 8694                obj.domain = DomainReader.read_one(reader)
 8695            elif tag == 'graphics_consoles':
 8696                obj.graphics_consoles = GraphicsConsoleReader.read_many(reader)
 8697            elif tag == 'high_availability':
 8698                obj.high_availability = HighAvailabilityReader.read_one(reader)
 8699            elif tag == 'initialization':
 8700                obj.initialization = InitializationReader.read_one(reader)
 8701            elif tag == 'io':
 8702                obj.io = IoReader.read_one(reader)
 8703            elif tag == 'large_icon':
 8704                obj.large_icon = IconReader.read_one(reader)
 8705            elif tag == 'lease':
 8706                obj.lease = StorageDomainLeaseReader.read_one(reader)
 8707            elif tag == 'mediated_devices':
 8708                obj.mediated_devices = VmMediatedDeviceReader.read_many(reader)
 8709            elif tag == 'memory':
 8710                obj.memory = Reader.read_integer(reader)
 8711            elif tag == 'memory_policy':
 8712                obj.memory_policy = MemoryPolicyReader.read_one(reader)
 8713            elif tag == 'migration':
 8714                obj.migration = MigrationOptionsReader.read_one(reader)
 8715            elif tag == 'migration_downtime':
 8716                obj.migration_downtime = Reader.read_integer(reader)
 8717            elif tag == 'multi_queues_enabled':
 8718                obj.multi_queues_enabled = Reader.read_boolean(reader)
 8719            elif tag == 'name':
 8720                obj.name = Reader.read_string(reader)
 8721            elif tag == 'nics':
 8722                obj.nics = NicReader.read_many(reader)
 8723            elif tag == 'origin':
 8724                obj.origin = Reader.read_string(reader)
 8725            elif tag == 'os':
 8726                obj.os = OperatingSystemReader.read_one(reader)
 8727            elif tag == 'permissions':
 8728                obj.permissions = PermissionReader.read_many(reader)
 8729            elif tag == 'placement_policy':
 8730                obj.placement_policy = VmPlacementPolicyReader.read_one(reader)
 8731            elif tag == 'quota':
 8732                obj.quota = QuotaReader.read_one(reader)
 8733            elif tag == 'rng_device':
 8734                obj.rng_device = RngDeviceReader.read_one(reader)
 8735            elif tag == 'serial_number':
 8736                obj.serial_number = SerialNumberReader.read_one(reader)
 8737            elif tag == 'small_icon':
 8738                obj.small_icon = IconReader.read_one(reader)
 8739            elif tag == 'soundcard_enabled':
 8740                obj.soundcard_enabled = Reader.read_boolean(reader)
 8741            elif tag == 'sso':
 8742                obj.sso = SsoReader.read_one(reader)
 8743            elif tag == 'start_paused':
 8744                obj.start_paused = Reader.read_boolean(reader)
 8745            elif tag == 'stateless':
 8746                obj.stateless = Reader.read_boolean(reader)
 8747            elif tag == 'status':
 8748                obj.status = Reader.read_enum(types.TemplateStatus, reader)
 8749            elif tag == 'storage_domain':
 8750                obj.storage_domain = StorageDomainReader.read_one(reader)
 8751            elif tag == 'storage_error_resume_behaviour':
 8752                obj.storage_error_resume_behaviour = Reader.read_enum(types.VmStorageErrorResumeBehaviour, reader)
 8753            elif tag == 'tags':
 8754                obj.tags = TagReader.read_many(reader)
 8755            elif tag == 'time_zone':
 8756                obj.time_zone = TimeZoneReader.read_one(reader)
 8757            elif tag == 'tpm_enabled':
 8758                obj.tpm_enabled = Reader.read_boolean(reader)
 8759            elif tag == 'tunnel_migration':
 8760                obj.tunnel_migration = Reader.read_boolean(reader)
 8761            elif tag == 'type':
 8762                obj.type = Reader.read_enum(types.VmType, reader)
 8763            elif tag == 'usb':
 8764                obj.usb = UsbReader.read_one(reader)
 8765            elif tag == 'version':
 8766                obj.version = TemplateVersionReader.read_one(reader)
 8767            elif tag == 'virtio_scsi':
 8768                obj.virtio_scsi = VirtioScsiReader.read_one(reader)
 8769            elif tag == 'virtio_scsi_multi_queues':
 8770                obj.virtio_scsi_multi_queues = Reader.read_integer(reader)
 8771            elif tag == 'virtio_scsi_multi_queues_enabled':
 8772                obj.virtio_scsi_multi_queues_enabled = Reader.read_boolean(reader)
 8773            elif tag == 'vm':
 8774                obj.vm = VmReader.read_one(reader)
 8775            elif tag == 'watchdogs':
 8776                obj.watchdogs = WatchdogReader.read_many(reader)
 8777            elif tag == 'link':
 8778                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 8779                reader.next_element()
 8780            else:
 8781                reader.next_element()
 8782        for link in links:
 8783            InstanceTypeReader._process_link(link, obj)
 8784
 8785        # Discard the end tag:
 8786        reader.read()
 8787
 8788        return obj
 8789
 8790    @staticmethod
 8791    def read_many(reader):
 8792        # Do nothing if there aren't more tags:
 8793        objs = List()
 8794        if not reader.forward():
 8795            return objs
 8796
 8797        # Process the attributes:
 8798        objs.href = reader.get_attribute('href')
 8799
 8800        # Discard the start tag:
 8801        empty = reader.empty_element()
 8802        reader.read()
 8803        if empty:
 8804            return objs
 8805
 8806        # Process the inner elements:
 8807        while reader.forward():
 8808            objs.append(InstanceTypeReader.read_one(reader))
 8809
 8810        # Discard the end tag:
 8811        reader.read()
 8812
 8813        return objs
 8814
 8815    @staticmethod
 8816    def _process_link(link, obj):
 8817        # Process the attributes:
 8818        rel = link[0]
 8819        href = link[1]
 8820        if href and rel:
 8821            if rel == "cdroms":
 8822                if obj.cdroms is not None:
 8823                    obj.cdroms.href = href
 8824                else:
 8825                    obj.cdroms = List(href)
 8826            elif rel == "diskattachments":
 8827                if obj.disk_attachments is not None:
 8828                    obj.disk_attachments.href = href
 8829                else:
 8830                    obj.disk_attachments = List(href)
 8831            elif rel == "graphicsconsoles":
 8832                if obj.graphics_consoles is not None:
 8833                    obj.graphics_consoles.href = href
 8834                else:
 8835                    obj.graphics_consoles = List(href)
 8836            elif rel == "mediateddevices":
 8837                if obj.mediated_devices is not None:
 8838                    obj.mediated_devices.href = href
 8839                else:
 8840                    obj.mediated_devices = List(href)
 8841            elif rel == "nics":
 8842                if obj.nics is not None:
 8843                    obj.nics.href = href
 8844                else:
 8845                    obj.nics = List(href)
 8846            elif rel == "permissions":
 8847                if obj.permissions is not None:
 8848                    obj.permissions.href = href
 8849                else:
 8850                    obj.permissions = List(href)
 8851            elif rel == "tags":
 8852                if obj.tags is not None:
 8853                    obj.tags.href = href
 8854                else:
 8855                    obj.tags = List(href)
 8856            elif rel == "watchdogs":
 8857                if obj.watchdogs is not None:
 8858                    obj.watchdogs.href = href
 8859                else:
 8860                    obj.watchdogs = List(href)
 8861
 8862
 8863class IoReader(Reader):
 8864
 8865    def __init__(self):
 8866        super(IoReader, self).__init__()
 8867
 8868    @staticmethod
 8869    def read_one(reader):
 8870        # Do nothing if there aren't more tags:
 8871        if not reader.forward():
 8872            return None
 8873
 8874        # Create the object:
 8875        obj = types.Io()
 8876
 8877        # Process the attributes:
 8878        obj.href = reader.get_attribute('href')
 8879
 8880        # Discard the start tag:
 8881        empty = reader.empty_element()
 8882        reader.read()
 8883        if empty:
 8884            return obj
 8885
 8886        # Process the inner elements:
 8887        links = []
 8888        while reader.forward():
 8889            tag = reader.node_name()
 8890            if tag == 'threads':
 8891                obj.threads = Reader.read_integer(reader)
 8892            else:
 8893                reader.next_element()
 8894        for link in links:
 8895            IoReader._process_link(link, obj)
 8896
 8897        # Discard the end tag:
 8898        reader.read()
 8899
 8900        return obj
 8901
 8902    @staticmethod
 8903    def read_many(reader):
 8904        # Do nothing if there aren't more tags:
 8905        objs = List()
 8906        if not reader.forward():
 8907            return objs
 8908
 8909        # Process the attributes:
 8910        objs.href = reader.get_attribute('href')
 8911
 8912        # Discard the start tag:
 8913        empty = reader.empty_element()
 8914        reader.read()
 8915        if empty:
 8916            return objs
 8917
 8918        # Process the inner elements:
 8919        while reader.forward():
 8920            objs.append(IoReader.read_one(reader))
 8921
 8922        # Discard the end tag:
 8923        reader.read()
 8924
 8925        return objs
 8926
 8927
 8928class IpReader(Reader):
 8929
 8930    def __init__(self):
 8931        super(IpReader, self).__init__()
 8932
 8933    @staticmethod
 8934    def read_one(reader):
 8935        # Do nothing if there aren't more tags:
 8936        if not reader.forward():
 8937            return None
 8938
 8939        # Create the object:
 8940        obj = types.Ip()
 8941
 8942        # Process the attributes:
 8943        obj.href = reader.get_attribute('href')
 8944
 8945        # Discard the start tag:
 8946        empty = reader.empty_element()
 8947        reader.read()
 8948        if empty:
 8949            return obj
 8950
 8951        # Process the inner elements:
 8952        links = []
 8953        while reader.forward():
 8954            tag = reader.node_name()
 8955            if tag == 'address':
 8956                obj.address = Reader.read_string(reader)
 8957            elif tag == 'gateway':
 8958                obj.gateway = Reader.read_string(reader)
 8959            elif tag == 'netmask':
 8960                obj.netmask = Reader.read_string(reader)
 8961            elif tag == 'version':
 8962                obj.version = Reader.read_enum(types.IpVersion, reader)
 8963            else:
 8964                reader.next_element()
 8965        for link in links:
 8966            IpReader._process_link(link, obj)
 8967
 8968        # Discard the end tag:
 8969        reader.read()
 8970
 8971        return obj
 8972
 8973    @staticmethod
 8974    def read_many(reader):
 8975        # Do nothing if there aren't more tags:
 8976        objs = List()
 8977        if not reader.forward():
 8978            return objs
 8979
 8980        # Process the attributes:
 8981        objs.href = reader.get_attribute('href')
 8982
 8983        # Discard the start tag:
 8984        empty = reader.empty_element()
 8985        reader.read()
 8986        if empty:
 8987            return objs
 8988
 8989        # Process the inner elements:
 8990        while reader.forward():
 8991            objs.append(IpReader.read_one(reader))
 8992
 8993        # Discard the end tag:
 8994        reader.read()
 8995
 8996        return objs
 8997
 8998
 8999class IpAddressAssignmentReader(Reader):
 9000
 9001    def __init__(self):
 9002        super(IpAddressAssignmentReader, self).__init__()
 9003
 9004    @staticmethod
 9005    def read_one(reader):
 9006        # Do nothing if there aren't more tags:
 9007        if not reader.forward():
 9008            return None
 9009
 9010        # Create the object:
 9011        obj = types.IpAddressAssignment()
 9012
 9013        # Process the attributes:
 9014        obj.href = reader.get_attribute('href')
 9015
 9016        # Discard the start tag:
 9017        empty = reader.empty_element()
 9018        reader.read()
 9019        if empty:
 9020            return obj
 9021
 9022        # Process the inner elements:
 9023        links = []
 9024        while reader.forward():
 9025            tag = reader.node_name()
 9026            if tag == 'assignment_method':
 9027                obj.assignment_method = Reader.read_enum(types.BootProtocol, reader)
 9028            elif tag == 'ip':
 9029                obj.ip = IpReader.read_one(reader)
 9030            else:
 9031                reader.next_element()
 9032        for link in links:
 9033            IpAddressAssignmentReader._process_link(link, obj)
 9034
 9035        # Discard the end tag:
 9036        reader.read()
 9037
 9038        return obj
 9039
 9040    @staticmethod
 9041    def read_many(reader):
 9042        # Do nothing if there aren't more tags:
 9043        objs = List()
 9044        if not reader.forward():
 9045            return objs
 9046
 9047        # Process the attributes:
 9048        objs.href = reader.get_attribute('href')
 9049
 9050        # Discard the start tag:
 9051        empty = reader.empty_element()
 9052        reader.read()
 9053        if empty:
 9054            return objs
 9055
 9056        # Process the inner elements:
 9057        while reader.forward():
 9058            objs.append(IpAddressAssignmentReader.read_one(reader))
 9059
 9060        # Discard the end tag:
 9061        reader.read()
 9062
 9063        return objs
 9064
 9065
 9066class IscsiBondReader(Reader):
 9067
 9068    def __init__(self):
 9069        super(IscsiBondReader, self).__init__()
 9070
 9071    @staticmethod
 9072    def read_one(reader):
 9073        # Do nothing if there aren't more tags:
 9074        if not reader.forward():
 9075            return None
 9076
 9077        # Create the object:
 9078        obj = types.IscsiBond()
 9079
 9080        # Process the attributes:
 9081        obj.href = reader.get_attribute('href')
 9082        value = reader.get_attribute('id')
 9083        if value is not None:
 9084            obj.id = value
 9085
 9086        # Discard the start tag:
 9087        empty = reader.empty_element()
 9088        reader.read()
 9089        if empty:
 9090            return obj
 9091
 9092        # Process the inner elements:
 9093        links = []
 9094        while reader.forward():
 9095            tag = reader.node_name()
 9096            if tag == 'comment':
 9097                obj.comment = Reader.read_string(reader)
 9098            elif tag == 'data_center':
 9099                obj.data_center = DataCenterReader.read_one(reader)
 9100            elif tag == 'description':
 9101                obj.description = Reader.read_string(reader)
 9102            elif tag == 'name':
 9103                obj.name = Reader.read_string(reader)
 9104            elif tag == 'networks':
 9105                obj.networks = NetworkReader.read_many(reader)
 9106            elif tag == 'storage_connections':
 9107                obj.storage_connections = StorageConnectionReader.read_many(reader)
 9108            elif tag == 'link':
 9109                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 9110                reader.next_element()
 9111            else:
 9112                reader.next_element()
 9113        for link in links:
 9114            IscsiBondReader._process_link(link, obj)
 9115
 9116        # Discard the end tag:
 9117        reader.read()
 9118
 9119        return obj
 9120
 9121    @staticmethod
 9122    def read_many(reader):
 9123        # Do nothing if there aren't more tags:
 9124        objs = List()
 9125        if not reader.forward():
 9126            return objs
 9127
 9128        # Process the attributes:
 9129        objs.href = reader.get_attribute('href')
 9130
 9131        # Discard the start tag:
 9132        empty = reader.empty_element()
 9133        reader.read()
 9134        if empty:
 9135            return objs
 9136
 9137        # Process the inner elements:
 9138        while reader.forward():
 9139            objs.append(IscsiBondReader.read_one(reader))
 9140
 9141        # Discard the end tag:
 9142        reader.read()
 9143
 9144        return objs
 9145
 9146    @staticmethod
 9147    def _process_link(link, obj):
 9148        # Process the attributes:
 9149        rel = link[0]
 9150        href = link[1]
 9151        if href and rel:
 9152            if rel == "networks":
 9153                if obj.networks is not None:
 9154                    obj.networks.href = href
 9155                else:
 9156                    obj.networks = List(href)
 9157            elif rel == "storageconnections":
 9158                if obj.storage_connections is not None:
 9159                    obj.storage_connections.href = href
 9160                else:
 9161                    obj.storage_connections = List(href)
 9162
 9163
 9164class IscsiDetailsReader(Reader):
 9165
 9166    def __init__(self):
 9167        super(IscsiDetailsReader, self).__init__()
 9168
 9169    @staticmethod
 9170    def read_one(reader):
 9171        # Do nothing if there aren't more tags:
 9172        if not reader.forward():
 9173            return None
 9174
 9175        # Create the object:
 9176        obj = types.IscsiDetails()
 9177
 9178        # Process the attributes:
 9179        obj.href = reader.get_attribute('href')
 9180
 9181        # Discard the start tag:
 9182        empty = reader.empty_element()
 9183        reader.read()
 9184        if empty:
 9185            return obj
 9186
 9187        # Process the inner elements:
 9188        links = []
 9189        while reader.forward():
 9190            tag = reader.node_name()
 9191            if tag == 'address':
 9192                obj.address = Reader.read_string(reader)
 9193            elif tag == 'disk_id':
 9194                obj.disk_id = Reader.read_string(reader)
 9195            elif tag == 'initiator':
 9196                obj.initiator = Reader.read_string(reader)
 9197            elif tag == 'lun_mapping':
 9198                obj.lun_mapping = Reader.read_integer(reader)
 9199            elif tag == 'password':
 9200                obj.password = Reader.read_string(reader)
 9201            elif tag == 'paths':
 9202                obj.paths = Reader.read_integer(reader)
 9203            elif tag == 'port':
 9204                obj.port = Reader.read_integer(reader)
 9205            elif tag == 'portal':
 9206                obj.portal = Reader.read_string(reader)
 9207            elif tag == 'product_id':
 9208                obj.product_id = Reader.read_string(reader)
 9209            elif tag == 'serial':
 9210                obj.serial = Reader.read_string(reader)
 9211            elif tag == 'size':
 9212                obj.size = Reader.read_integer(reader)
 9213            elif tag == 'status':
 9214                obj.status = Reader.read_string(reader)
 9215            elif tag == 'storage_domain_id':
 9216                obj.storage_domain_id = Reader.read_string(reader)
 9217            elif tag == 'target':
 9218                obj.target = Reader.read_string(reader)
 9219            elif tag == 'username':
 9220                obj.username = Reader.read_string(reader)
 9221            elif tag == 'vendor_id':
 9222                obj.vendor_id = Reader.read_string(reader)
 9223            elif tag == 'volume_group_id':
 9224                obj.volume_group_id = Reader.read_string(reader)
 9225            else:
 9226                reader.next_element()
 9227        for link in links:
 9228            IscsiDetailsReader._process_link(link, obj)
 9229
 9230        # Discard the end tag:
 9231        reader.read()
 9232
 9233        return obj
 9234
 9235    @staticmethod
 9236    def read_many(reader):
 9237        # Do nothing if there aren't more tags:
 9238        objs = List()
 9239        if not reader.forward():
 9240            return objs
 9241
 9242        # Process the attributes:
 9243        objs.href = reader.get_attribute('href')
 9244
 9245        # Discard the start tag:
 9246        empty = reader.empty_element()
 9247        reader.read()
 9248        if empty:
 9249            return objs
 9250
 9251        # Process the inner elements:
 9252        while reader.forward():
 9253            objs.append(IscsiDetailsReader.read_one(reader))
 9254
 9255        # Discard the end tag:
 9256        reader.read()
 9257
 9258        return objs
 9259
 9260
 9261class JobReader(Reader):
 9262
 9263    def __init__(self):
 9264        super(JobReader, self).__init__()
 9265
 9266    @staticmethod
 9267    def read_one(reader):
 9268        # Do nothing if there aren't more tags:
 9269        if not reader.forward():
 9270            return None
 9271
 9272        # Create the object:
 9273        obj = types.Job()
 9274
 9275        # Process the attributes:
 9276        obj.href = reader.get_attribute('href')
 9277        value = reader.get_attribute('id')
 9278        if value is not None:
 9279            obj.id = value
 9280
 9281        # Discard the start tag:
 9282        empty = reader.empty_element()
 9283        reader.read()
 9284        if empty:
 9285            return obj
 9286
 9287        # Process the inner elements:
 9288        links = []
 9289        while reader.forward():
 9290            tag = reader.node_name()
 9291            if tag == 'auto_cleared':
 9292                obj.auto_cleared = Reader.read_boolean(reader)
 9293            elif tag == 'comment':
 9294                obj.comment = Reader.read_string(reader)
 9295            elif tag == 'description':
 9296                obj.description = Reader.read_string(reader)
 9297            elif tag == 'end_time':
 9298                obj.end_time = Reader.read_date(reader)
 9299            elif tag == 'external':
 9300                obj.external = Reader.read_boolean(reader)
 9301            elif tag == 'last_updated':
 9302                obj.last_updated = Reader.read_date(reader)
 9303            elif tag == 'name':
 9304                obj.name = Reader.read_string(reader)
 9305            elif tag == 'owner':
 9306                obj.owner = UserReader.read_one(reader)
 9307            elif tag == 'start_time':
 9308                obj.start_time = Reader.read_date(reader)
 9309            elif tag == 'status':
 9310                obj.status = Reader.read_enum(types.JobStatus, reader)
 9311            elif tag == 'steps':
 9312                obj.steps = StepReader.read_many(reader)
 9313            elif tag == 'link':
 9314                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 9315                reader.next_element()
 9316            else:
 9317                reader.next_element()
 9318        for link in links:
 9319            JobReader._process_link(link, obj)
 9320
 9321        # Discard the end tag:
 9322        reader.read()
 9323
 9324        return obj
 9325
 9326    @staticmethod
 9327    def read_many(reader):
 9328        # Do nothing if there aren't more tags:
 9329        objs = List()
 9330        if not reader.forward():
 9331            return objs
 9332
 9333        # Process the attributes:
 9334        objs.href = reader.get_attribute('href')
 9335
 9336        # Discard the start tag:
 9337        empty = reader.empty_element()
 9338        reader.read()
 9339        if empty:
 9340            return objs
 9341
 9342        # Process the inner elements:
 9343        while reader.forward():
 9344            objs.append(JobReader.read_one(reader))
 9345
 9346        # Discard the end tag:
 9347        reader.read()
 9348
 9349        return objs
 9350
 9351    @staticmethod
 9352    def _process_link(link, obj):
 9353        # Process the attributes:
 9354        rel = link[0]
 9355        href = link[1]
 9356        if href and rel:
 9357            if rel == "steps":
 9358                if obj.steps is not None:
 9359                    obj.steps.href = href
 9360                else:
 9361                    obj.steps = List(href)
 9362
 9363
 9364class KatelloErratumReader(Reader):
 9365
 9366    def __init__(self):
 9367        super(KatelloErratumReader, self).__init__()
 9368
 9369    @staticmethod
 9370    def read_one(reader):
 9371        # Do nothing if there aren't more tags:
 9372        if not reader.forward():
 9373            return None
 9374
 9375        # Create the object:
 9376        obj = types.KatelloErratum()
 9377
 9378        # Process the attributes:
 9379        obj.href = reader.get_attribute('href')
 9380        value = reader.get_attribute('id')
 9381        if value is not None:
 9382            obj.id = value
 9383
 9384        # Discard the start tag:
 9385        empty = reader.empty_element()
 9386        reader.read()
 9387        if empty:
 9388            return obj
 9389
 9390        # Process the inner elements:
 9391        links = []
 9392        while reader.forward():
 9393            tag = reader.node_name()
 9394            if tag == 'comment':
 9395                obj.comment = Reader.read_string(reader)
 9396            elif tag == 'description':
 9397                obj.description = Reader.read_string(reader)
 9398            elif tag == 'host':
 9399                obj.host = HostReader.read_one(reader)
 9400            elif tag == 'issued':
 9401                obj.issued = Reader.read_date(reader)
 9402            elif tag == 'name':
 9403                obj.name = Reader.read_string(reader)
 9404            elif tag == 'packages':
 9405                obj.packages = PackageReader.read_many(reader)
 9406            elif tag == 'severity':
 9407                obj.severity = Reader.read_string(reader)
 9408            elif tag == 'solution':
 9409                obj.solution = Reader.read_string(reader)
 9410            elif tag == 'summary':
 9411                obj.summary = Reader.read_string(reader)
 9412            elif tag == 'title':
 9413                obj.title = Reader.read_string(reader)
 9414            elif tag == 'type':
 9415                obj.type = Reader.read_string(reader)
 9416            elif tag == 'vm':
 9417                obj.vm = VmReader.read_one(reader)
 9418            else:
 9419                reader.next_element()
 9420        for link in links:
 9421            KatelloErratumReader._process_link(link, obj)
 9422
 9423        # Discard the end tag:
 9424        reader.read()
 9425
 9426        return obj
 9427
 9428    @staticmethod
 9429    def read_many(reader):
 9430        # Do nothing if there aren't more tags:
 9431        objs = List()
 9432        if not reader.forward():
 9433            return objs
 9434
 9435        # Process the attributes:
 9436        objs.href = reader.get_attribute('href')
 9437
 9438        # Discard the start tag:
 9439        empty = reader.empty_element()
 9440        reader.read()
 9441        if empty:
 9442            return objs
 9443
 9444        # Process the inner elements:
 9445        while reader.forward():
 9446            objs.append(KatelloErratumReader.read_one(reader))
 9447
 9448        # Discard the end tag:
 9449        reader.read()
 9450
 9451        return objs
 9452
 9453
 9454class KernelReader(Reader):
 9455
 9456    def __init__(self):
 9457        super(KernelReader, self).__init__()
 9458
 9459    @staticmethod
 9460    def read_one(reader):
 9461        # Do nothing if there aren't more tags:
 9462        if not reader.forward():
 9463            return None
 9464
 9465        # Create the object:
 9466        obj = types.Kernel()
 9467
 9468        # Process the attributes:
 9469        obj.href = reader.get_attribute('href')
 9470
 9471        # Discard the start tag:
 9472        empty = reader.empty_element()
 9473        reader.read()
 9474        if empty:
 9475            return obj
 9476
 9477        # Process the inner elements:
 9478        links = []
 9479        while reader.forward():
 9480            tag = reader.node_name()
 9481            if tag == 'version':
 9482                obj.version = VersionReader.read_one(reader)
 9483            else:
 9484                reader.next_element()
 9485        for link in links:
 9486            KernelReader._process_link(link, obj)
 9487
 9488        # Discard the end tag:
 9489        reader.read()
 9490
 9491        return obj
 9492
 9493    @staticmethod
 9494    def read_many(reader):
 9495        # Do nothing if there aren't more tags:
 9496        objs = List()
 9497        if not reader.forward():
 9498            return objs
 9499
 9500        # Process the attributes:
 9501        objs.href = reader.get_attribute('href')
 9502
 9503        # Discard the start tag:
 9504        empty = reader.empty_element()
 9505        reader.read()
 9506        if empty:
 9507            return objs
 9508
 9509        # Process the inner elements:
 9510        while reader.forward():
 9511            objs.append(KernelReader.read_one(reader))
 9512
 9513        # Discard the end tag:
 9514        reader.read()
 9515
 9516        return objs
 9517
 9518
 9519class KsmReader(Reader):
 9520
 9521    def __init__(self):
 9522        super(KsmReader, self).__init__()
 9523
 9524    @staticmethod
 9525    def read_one(reader):
 9526        # Do nothing if there aren't more tags:
 9527        if not reader.forward():
 9528            return None
 9529
 9530        # Create the object:
 9531        obj = types.Ksm()
 9532
 9533        # Process the attributes:
 9534        obj.href = reader.get_attribute('href')
 9535
 9536        # Discard the start tag:
 9537        empty = reader.empty_element()
 9538        reader.read()
 9539        if empty:
 9540            return obj
 9541
 9542        # Process the inner elements:
 9543        links = []
 9544        while reader.forward():
 9545            tag = reader.node_name()
 9546            if tag == 'enabled':
 9547                obj.enabled = Reader.read_boolean(reader)
 9548            elif tag == 'merge_across_nodes':
 9549                obj.merge_across_nodes = Reader.read_boolean(reader)
 9550            else:
 9551                reader.next_element()
 9552        for link in links:
 9553            KsmReader._process_link(link, obj)
 9554
 9555        # Discard the end tag:
 9556        reader.read()
 9557
 9558        return obj
 9559
 9560    @staticmethod
 9561    def read_many(reader):
 9562        # Do nothing if there aren't more tags:
 9563        objs = List()
 9564        if not reader.forward():
 9565            return objs
 9566
 9567        # Process the attributes:
 9568        objs.href = reader.get_attribute('href')
 9569
 9570        # Discard the start tag:
 9571        empty = reader.empty_element()
 9572        reader.read()
 9573        if empty:
 9574            return objs
 9575
 9576        # Process the inner elements:
 9577        while reader.forward():
 9578            objs.append(KsmReader.read_one(reader))
 9579
 9580        # Discard the end tag:
 9581        reader.read()
 9582
 9583        return objs
 9584
 9585
 9586class LinkLayerDiscoveryProtocolElementReader(Reader):
 9587
 9588    def __init__(self):
 9589        super(LinkLayerDiscoveryProtocolElementReader, self).__init__()
 9590
 9591    @staticmethod
 9592    def read_one(reader):
 9593        # Do nothing if there aren't more tags:
 9594        if not reader.forward():
 9595            return None
 9596
 9597        # Create the object:
 9598        obj = types.LinkLayerDiscoveryProtocolElement()
 9599
 9600        # Process the attributes:
 9601        obj.href = reader.get_attribute('href')
 9602        value = reader.get_attribute('id')
 9603        if value is not None:
 9604            obj.id = value
 9605
 9606        # Discard the start tag:
 9607        empty = reader.empty_element()
 9608        reader.read()
 9609        if empty:
 9610            return obj
 9611
 9612        # Process the inner elements:
 9613        links = []
 9614        while reader.forward():
 9615            tag = reader.node_name()
 9616            if tag == 'comment':
 9617                obj.comment = Reader.read_string(reader)
 9618            elif tag == 'description':
 9619                obj.description = Reader.read_string(reader)
 9620            elif tag == 'name':
 9621                obj.name = Reader.read_string(reader)
 9622            elif tag == 'oui':
 9623                obj.oui = Reader.read_integer(reader)
 9624            elif tag == 'properties':
 9625                obj.properties = PropertyReader.read_many(reader)
 9626            elif tag == 'subtype':
 9627                obj.subtype = Reader.read_integer(reader)
 9628            elif tag == 'type':
 9629                obj.type = Reader.read_integer(reader)
 9630            else:
 9631                reader.next_element()
 9632        for link in links:
 9633            LinkLayerDiscoveryProtocolElementReader._process_link(link, obj)
 9634
 9635        # Discard the end tag:
 9636        reader.read()
 9637
 9638        return obj
 9639
 9640    @staticmethod
 9641    def read_many(reader):
 9642        # Do nothing if there aren't more tags:
 9643        objs = List()
 9644        if not reader.forward():
 9645            return objs
 9646
 9647        # Process the attributes:
 9648        objs.href = reader.get_attribute('href')
 9649
 9650        # Discard the start tag:
 9651        empty = reader.empty_element()
 9652        reader.read()
 9653        if empty:
 9654            return objs
 9655
 9656        # Process the inner elements:
 9657        while reader.forward():
 9658            objs.append(LinkLayerDiscoveryProtocolElementReader.read_one(reader))
 9659
 9660        # Discard the end tag:
 9661        reader.read()
 9662
 9663        return objs
 9664
 9665
 9666class LogicalUnitReader(Reader):
 9667
 9668    def __init__(self):
 9669        super(LogicalUnitReader, self).__init__()
 9670
 9671    @staticmethod
 9672    def read_one(reader):
 9673        # Do nothing if there aren't more tags:
 9674        if not reader.forward():
 9675            return None
 9676
 9677        # Create the object:
 9678        obj = types.LogicalUnit()
 9679
 9680        # Process the attributes:
 9681        obj.href = reader.get_attribute('href')
 9682        value = reader.get_attribute('id')
 9683        if value is not None:
 9684            obj.id = value
 9685
 9686        # Discard the start tag:
 9687        empty = reader.empty_element()
 9688        reader.read()
 9689        if empty:
 9690            return obj
 9691
 9692        # Process the inner elements:
 9693        links = []
 9694        while reader.forward():
 9695            tag = reader.node_name()
 9696            if tag == 'address':
 9697                obj.address = Reader.read_string(reader)
 9698            elif tag == 'discard_max_size':
 9699                obj.discard_max_size = Reader.read_integer(reader)
 9700            elif tag == 'discard_zeroes_data':
 9701                obj.discard_zeroes_data = Reader.read_boolean(reader)
 9702            elif tag == 'disk_id':
 9703                obj.disk_id = Reader.read_string(reader)
 9704            elif tag == 'lun_mapping':
 9705                obj.lun_mapping = Reader.read_integer(reader)
 9706            elif tag == 'password':
 9707                obj.password = Reader.read_string(reader)
 9708            elif tag == 'paths':
 9709                obj.paths = Reader.read_integer(reader)
 9710            elif tag == 'port':
 9711                obj.port = Reader.read_integer(reader)
 9712            elif tag == 'portal':
 9713                obj.portal = Reader.read_string(reader)
 9714            elif tag == 'product_id':
 9715                obj.product_id = Reader.read_string(reader)
 9716            elif tag == 'serial':
 9717                obj.serial = Reader.read_string(reader)
 9718            elif tag == 'size':
 9719                obj.size = Reader.read_integer(reader)
 9720            elif tag == 'status':
 9721                obj.status = Reader.read_enum(types.LunStatus, reader)
 9722            elif tag == 'storage_domain_id':
 9723                obj.storage_domain_id = Reader.read_string(reader)
 9724            elif tag == 'target':
 9725                obj.target = Reader.read_string(reader)
 9726            elif tag == 'username':
 9727                obj.username = Reader.read_string(reader)
 9728            elif tag == 'vendor_id':
 9729                obj.vendor_id = Reader.read_string(reader)
 9730            elif tag == 'volume_group_id':
 9731                obj.volume_group_id = Reader.read_string(reader)
 9732            else:
 9733                reader.next_element()
 9734        for link in links:
 9735            LogicalUnitReader._process_link(link, obj)
 9736
 9737        # Discard the end tag:
 9738        reader.read()
 9739
 9740        return obj
 9741
 9742    @staticmethod
 9743    def read_many(reader):
 9744        # Do nothing if there aren't more tags:
 9745        objs = List()
 9746        if not reader.forward():
 9747            return objs
 9748
 9749        # Process the attributes:
 9750        objs.href = reader.get_attribute('href')
 9751
 9752        # Discard the start tag:
 9753        empty = reader.empty_element()
 9754        reader.read()
 9755        if empty:
 9756            return objs
 9757
 9758        # Process the inner elements:
 9759        while reader.forward():
 9760            objs.append(LogicalUnitReader.read_one(reader))
 9761
 9762        # Discard the end tag:
 9763        reader.read()
 9764
 9765        return objs
 9766
 9767
 9768class MDevTypeReader(Reader):
 9769
 9770    def __init__(self):
 9771        super(MDevTypeReader, self).__init__()
 9772
 9773    @staticmethod
 9774    def read_one(reader):
 9775        # Do nothing if there aren't more tags:
 9776        if not reader.forward():
 9777            return None
 9778
 9779        # Create the object:
 9780        obj = types.MDevType()
 9781
 9782        # Process the attributes:
 9783        obj.href = reader.get_attribute('href')
 9784
 9785        # Discard the start tag:
 9786        empty = reader.empty_element()
 9787        reader.read()
 9788        if empty:
 9789            return obj
 9790
 9791        # Process the inner elements:
 9792        links = []
 9793        while reader.forward():
 9794            tag = reader.node_name()
 9795            if tag == 'available_instances':
 9796                obj.available_instances = Reader.read_integer(reader)
 9797            elif tag == 'description':
 9798                obj.description = Reader.read_string(reader)
 9799            elif tag == 'human_readable_name':
 9800                obj.human_readable_name = Reader.read_string(reader)
 9801            elif tag == 'name':
 9802                obj.name = Reader.read_string(reader)
 9803            else:
 9804                reader.next_element()
 9805        for link in links:
 9806            MDevTypeReader._process_link(link, obj)
 9807
 9808        # Discard the end tag:
 9809        reader.read()
 9810
 9811        return obj
 9812
 9813    @staticmethod
 9814    def read_many(reader):
 9815        # Do nothing if there aren't more tags:
 9816        objs = List()
 9817        if not reader.forward():
 9818            return objs
 9819
 9820        # Process the attributes:
 9821        objs.href = reader.get_attribute('href')
 9822
 9823        # Discard the start tag:
 9824        empty = reader.empty_element()
 9825        reader.read()
 9826        if empty:
 9827            return objs
 9828
 9829        # Process the inner elements:
 9830        while reader.forward():
 9831            objs.append(MDevTypeReader.read_one(reader))
 9832
 9833        # Discard the end tag:
 9834        reader.read()
 9835
 9836        return objs
 9837
 9838
 9839class MacReader(Reader):
 9840
 9841    def __init__(self):
 9842        super(MacReader, self).__init__()
 9843
 9844    @staticmethod
 9845    def read_one(reader):
 9846        # Do nothing if there aren't more tags:
 9847        if not reader.forward():
 9848            return None
 9849
 9850        # Create the object:
 9851        obj = types.Mac()
 9852
 9853        # Process the attributes:
 9854        obj.href = reader.get_attribute('href')
 9855
 9856        # Discard the start tag:
 9857        empty = reader.empty_element()
 9858        reader.read()
 9859        if empty:
 9860            return obj
 9861
 9862        # Process the inner elements:
 9863        links = []
 9864        while reader.forward():
 9865            tag = reader.node_name()
 9866            if tag == 'address':
 9867                obj.address = Reader.read_string(reader)
 9868            else:
 9869                reader.next_element()
 9870        for link in links:
 9871            MacReader._process_link(link, obj)
 9872
 9873        # Discard the end tag:
 9874        reader.read()
 9875
 9876        return obj
 9877
 9878    @staticmethod
 9879    def read_many(reader):
 9880        # Do nothing if there aren't more tags:
 9881        objs = List()
 9882        if not reader.forward():
 9883            return objs
 9884
 9885        # Process the attributes:
 9886        objs.href = reader.get_attribute('href')
 9887
 9888        # Discard the start tag:
 9889        empty = reader.empty_element()
 9890        reader.read()
 9891        if empty:
 9892            return objs
 9893
 9894        # Process the inner elements:
 9895        while reader.forward():
 9896            objs.append(MacReader.read_one(reader))
 9897
 9898        # Discard the end tag:
 9899        reader.read()
 9900
 9901        return objs
 9902
 9903
 9904class MacPoolReader(Reader):
 9905
 9906    def __init__(self):
 9907        super(MacPoolReader, self).__init__()
 9908
 9909    @staticmethod
 9910    def read_one(reader):
 9911        # Do nothing if there aren't more tags:
 9912        if not reader.forward():
 9913            return None
 9914
 9915        # Create the object:
 9916        obj = types.MacPool()
 9917
 9918        # Process the attributes:
 9919        obj.href = reader.get_attribute('href')
 9920        value = reader.get_attribute('id')
 9921        if value is not None:
 9922            obj.id = value
 9923
 9924        # Discard the start tag:
 9925        empty = reader.empty_element()
 9926        reader.read()
 9927        if empty:
 9928            return obj
 9929
 9930        # Process the inner elements:
 9931        links = []
 9932        while reader.forward():
 9933            tag = reader.node_name()
 9934            if tag == 'allow_duplicates':
 9935                obj.allow_duplicates = Reader.read_boolean(reader)
 9936            elif tag == 'comment':
 9937                obj.comment = Reader.read_string(reader)
 9938            elif tag == 'default_pool':
 9939                obj.default_pool = Reader.read_boolean(reader)
 9940            elif tag == 'description':
 9941                obj.description = Reader.read_string(reader)
 9942            elif tag == 'name':
 9943                obj.name = Reader.read_string(reader)
 9944            elif tag == 'permissions':
 9945                obj.permissions = PermissionReader.read_many(reader)
 9946            elif tag == 'ranges':
 9947                obj.ranges = RangeReader.read_many(reader)
 9948            elif tag == 'link':
 9949                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
 9950                reader.next_element()
 9951            else:
 9952                reader.next_element()
 9953        for link in links:
 9954            MacPoolReader._process_link(link, obj)
 9955
 9956        # Discard the end tag:
 9957        reader.read()
 9958
 9959        return obj
 9960
 9961    @staticmethod
 9962    def read_many(reader):
 9963        # Do nothing if there aren't more tags:
 9964        objs = List()
 9965        if not reader.forward():
 9966            return objs
 9967
 9968        # Process the attributes:
 9969        objs.href = reader.get_attribute('href')
 9970
 9971        # Discard the start tag:
 9972        empty = reader.empty_element()
 9973        reader.read()
 9974        if empty:
 9975            return objs
 9976
 9977        # Process the inner elements:
 9978        while reader.forward():
 9979            objs.append(MacPoolReader.read_one(reader))
 9980
 9981        # Discard the end tag:
 9982        reader.read()
 9983
 9984        return objs
 9985
 9986    @staticmethod
 9987    def _process_link(link, obj):
 9988        # Process the attributes:
 9989        rel = link[0]
 9990        href = link[1]
 9991        if href and rel:
 9992            if rel == "permissions":
 9993                if obj.permissions is not None:
 9994                    obj.permissions.href = href
 9995                else:
 9996                    obj.permissions = List(href)
 9997
 9998
 9999class MemoryOverCommitReader(Reader):
10000
10001    def __init__(self):
10002        super(MemoryOverCommitReader, self).__init__()
10003
10004    @staticmethod
10005    def read_one(reader):
10006        # Do nothing if there aren't more tags:
10007        if not reader.forward():
10008            return None
10009
10010        # Create the object:
10011        obj = types.MemoryOverCommit()
10012
10013        # Process the attributes:
10014        obj.href = reader.get_attribute('href')
10015
10016        # Discard the start tag:
10017        empty = reader.empty_element()
10018        reader.read()
10019        if empty:
10020            return obj
10021
10022        # Process the inner elements:
10023        links = []
10024        while reader.forward():
10025            tag = reader.node_name()
10026            if tag == 'percent':
10027                obj.percent = Reader.read_integer(reader)
10028            else:
10029                reader.next_element()
10030        for link in links:
10031            MemoryOverCommitReader._process_link(link, obj)
10032
10033        # Discard the end tag:
10034        reader.read()
10035
10036        return obj
10037
10038    @staticmethod
10039    def read_many(reader):
10040        # Do nothing if there aren't more tags:
10041        objs = List()
10042        if not reader.forward():
10043            return objs
10044
10045        # Process the attributes:
10046        objs.href = reader.get_attribute('href')
10047
10048        # Discard the start tag:
10049        empty = reader.empty_element()
10050        reader.read()
10051        if empty:
10052            return objs
10053
10054        # Process the inner elements:
10055        while reader.forward():
10056            objs.append(MemoryOverCommitReader.read_one(reader))
10057
10058        # Discard the end tag:
10059        reader.read()
10060
10061        return objs
10062
10063
10064class MemoryPolicyReader(Reader):
10065
10066    def __init__(self):
10067        super(MemoryPolicyReader, self).__init__()
10068
10069    @staticmethod
10070    def read_one(reader):
10071        # Do nothing if there aren't more tags:
10072        if not reader.forward():
10073            return None
10074
10075        # Create the object:
10076        obj = types.MemoryPolicy()
10077
10078        # Process the attributes:
10079        obj.href = reader.get_attribute('href')
10080
10081        # Discard the start tag:
10082        empty = reader.empty_element()
10083        reader.read()
10084        if empty:
10085            return obj
10086
10087        # Process the inner elements:
10088        links = []
10089        while reader.forward():
10090            tag = reader.node_name()
10091            if tag == 'ballooning':
10092                obj.ballooning = Reader.read_boolean(reader)
10093            elif tag == 'guaranteed':
10094                obj.guaranteed = Reader.read_integer(reader)
10095            elif tag == 'max':
10096                obj.max = Reader.read_integer(reader)
10097            elif tag == 'over_commit':
10098                obj.over_commit = MemoryOverCommitReader.read_one(reader)
10099            elif tag == 'transparent_hugepages':
10100                obj.transparent_huge_pages = TransparentHugePagesReader.read_one(reader)
10101            else:
10102                reader.next_element()
10103        for link in links:
10104            MemoryPolicyReader._process_link(link, obj)
10105
10106        # Discard the end tag:
10107        reader.read()
10108
10109        return obj
10110
10111    @staticmethod
10112    def read_many(reader):
10113        # Do nothing if there aren't more tags:
10114        objs = List()
10115        if not reader.forward():
10116            return objs
10117
10118        # Process the attributes:
10119        objs.href = reader.get_attribute('href')
10120
10121        # Discard the start tag:
10122        empty = reader.empty_element()
10123        reader.read()
10124        if empty:
10125            return objs
10126
10127        # Process the inner elements:
10128        while reader.forward():
10129            objs.append(MemoryPolicyReader.read_one(reader))
10130
10131        # Discard the end tag:
10132        reader.read()
10133
10134        return objs
10135
10136
10137class MethodReader(Reader):
10138
10139    def __init__(self):
10140        super(MethodReader, self).__init__()
10141
10142    @staticmethod
10143    def read_one(reader):
10144        # Do nothing if there aren't more tags:
10145        if not reader.forward():
10146            return None
10147
10148        # Create the object:
10149        obj = types.Method()
10150
10151        # Process the attributes:
10152        obj.href = reader.get_attribute('href')
10153        value = reader.get_attribute('id')
10154        if value is not None:
10155            obj.id = types.SsoMethod(value.lower())
10156
10157        # Discard the start tag:
10158        empty = reader.empty_element()
10159        reader.read()
10160        if empty:
10161            return obj
10162
10163        # Process the inner elements:
10164        reader.next_element()
10165
10166        # Discard the end tag:
10167        reader.read()
10168
10169        return obj
10170
10171    @staticmethod
10172    def read_many(reader):
10173        # Do nothing if there aren't more tags:
10174        objs = List()
10175        if not reader.forward():
10176            return objs
10177
10178        # Process the attributes:
10179        objs.href = reader.get_attribute('href')
10180
10181        # Discard the start tag:
10182        empty = reader.empty_element()
10183        reader.read()
10184        if empty:
10185            return objs
10186
10187        # Process the inner elements:
10188        while reader.forward():
10189            objs.append(MethodReader.read_one(reader))
10190
10191        # Discard the end tag:
10192        reader.read()
10193
10194        return objs
10195
10196
10197class MigrationBandwidthReader(Reader):
10198
10199    def __init__(self):
10200        super(MigrationBandwidthReader, self).__init__()
10201
10202    @staticmethod
10203    def read_one(reader):
10204        # Do nothing if there aren't more tags:
10205        if not reader.forward():
10206            return None
10207
10208        # Create the object:
10209        obj = types.MigrationBandwidth()
10210
10211        # Process the attributes:
10212        obj.href = reader.get_attribute('href')
10213
10214        # Discard the start tag:
10215        empty = reader.empty_element()
10216        reader.read()
10217        if empty:
10218            return obj
10219
10220        # Process the inner elements:
10221        links = []
10222        while reader.forward():
10223            tag = reader.node_name()
10224            if tag == 'assignment_method':
10225                obj.assignment_method = Reader.read_enum(types.MigrationBandwidthAssignmentMethod, reader)
10226            elif tag == 'custom_value':
10227                obj.custom_value = Reader.read_integer(reader)
10228            else:
10229                reader.next_element()
10230        for link in links:
10231            MigrationBandwidthReader._process_link(link, obj)
10232
10233        # Discard the end tag:
10234        reader.read()
10235
10236        return obj
10237
10238    @staticmethod
10239    def read_many(reader):
10240        # Do nothing if there aren't more tags:
10241        objs = List()
10242        if not reader.forward():
10243            return objs
10244
10245        # Process the attributes:
10246        objs.href = reader.get_attribute('href')
10247
10248        # Discard the start tag:
10249        empty = reader.empty_element()
10250        reader.read()
10251        if empty:
10252            return objs
10253
10254        # Process the inner elements:
10255        while reader.forward():
10256            objs.append(MigrationBandwidthReader.read_one(reader))
10257
10258        # Discard the end tag:
10259        reader.read()
10260
10261        return objs
10262
10263
10264class MigrationOptionsReader(Reader):
10265
10266    def __init__(self):
10267        super(MigrationOptionsReader, self).__init__()
10268
10269    @staticmethod
10270    def read_one(reader):
10271        # Do nothing if there aren't more tags:
10272        if not reader.forward():
10273            return None
10274
10275        # Create the object:
10276        obj = types.MigrationOptions()
10277
10278        # Process the attributes:
10279        obj.href = reader.get_attribute('href')
10280
10281        # Discard the start tag:
10282        empty = reader.empty_element()
10283        reader.read()
10284        if empty:
10285            return obj
10286
10287        # Process the inner elements:
10288        links = []
10289        while reader.forward():
10290            tag = reader.node_name()
10291            if tag == 'auto_converge':
10292                obj.auto_converge = Reader.read_enum(types.InheritableBoolean, reader)
10293            elif tag == 'bandwidth':
10294                obj.bandwidth = MigrationBandwidthReader.read_one(reader)
10295            elif tag == 'compressed':
10296                obj.compressed = Reader.read_enum(types.InheritableBoolean, reader)
10297            elif tag == 'encrypted':
10298                obj.encrypted = Reader.read_enum(types.InheritableBoolean, reader)
10299            elif tag == 'policy':
10300                obj.policy = MigrationPolicyReader.read_one(reader)
10301            else:
10302                reader.next_element()
10303        for link in links:
10304            MigrationOptionsReader._process_link(link, obj)
10305
10306        # Discard the end tag:
10307        reader.read()
10308
10309        return obj
10310
10311    @staticmethod
10312    def read_many(reader):
10313        # Do nothing if there aren't more tags:
10314        objs = List()
10315        if not reader.forward():
10316            return objs
10317
10318        # Process the attributes:
10319        objs.href = reader.get_attribute('href')
10320
10321        # Discard the start tag:
10322        empty = reader.empty_element()
10323        reader.read()
10324        if empty:
10325            return objs
10326
10327        # Process the inner elements:
10328        while reader.forward():
10329            objs.append(MigrationOptionsReader.read_one(reader))
10330
10331        # Discard the end tag:
10332        reader.read()
10333
10334        return objs
10335
10336
10337class MigrationPolicyReader(Reader):
10338
10339    def __init__(self):
10340        super(MigrationPolicyReader, self).__init__()
10341
10342    @staticmethod
10343    def read_one(reader):
10344        # Do nothing if there aren't more tags:
10345        if not reader.forward():
10346            return None
10347
10348        # Create the object:
10349        obj = types.MigrationPolicy()
10350
10351        # Process the attributes:
10352        obj.href = reader.get_attribute('href')
10353        value = reader.get_attribute('id')
10354        if value is not None:
10355            obj.id = value
10356
10357        # Discard the start tag:
10358        empty = reader.empty_element()
10359        reader.read()
10360        if empty:
10361            return obj
10362
10363        # Process the inner elements:
10364        links = []
10365        while reader.forward():
10366            tag = reader.node_name()
10367            if tag == 'comment':
10368                obj.comment = Reader.read_string(reader)
10369            elif tag == 'description':
10370                obj.description = Reader.read_string(reader)
10371            elif tag == 'name':
10372                obj.name = Reader.read_string(reader)
10373            else:
10374                reader.next_element()
10375        for link in links:
10376            MigrationPolicyReader._process_link(link, obj)
10377
10378        # Discard the end tag:
10379        reader.read()
10380
10381        return obj
10382
10383    @staticmethod
10384    def read_many(reader):
10385        # Do nothing if there aren't more tags:
10386        objs = List()
10387        if not reader.forward():
10388            return objs
10389
10390        # Process the attributes:
10391        objs.href = reader.get_attribute('href')
10392
10393        # Discard the start tag:
10394        empty = reader.empty_element()
10395        reader.read()
10396        if empty:
10397            return objs
10398
10399        # Process the inner elements:
10400        while reader.forward():
10401            objs.append(MigrationPolicyReader.read_one(reader))
10402
10403        # Discard the end tag:
10404        reader.read()
10405
10406        return objs
10407
10408
10409class NetworkReader(Reader):
10410
10411    def __init__(self):
10412        super(NetworkReader, self).__init__()
10413
10414    @staticmethod
10415    def read_one(reader):
10416        # Do nothing if there aren't more tags:
10417        if not reader.forward():
10418            return None
10419
10420        # Create the object:
10421        obj = types.Network()
10422
10423        # Process the attributes:
10424        obj.href = reader.get_attribute('href')
10425        value = reader.get_attribute('id')
10426        if value is not None:
10427            obj.id = value
10428
10429        # Discard the start tag:
10430        empty = reader.empty_element()
10431        reader.read()
10432        if empty:
10433            return obj
10434
10435        # Process the inner elements:
10436        links = []
10437        while reader.forward():
10438            tag = reader.node_name()
10439            if tag == 'cluster':
10440                obj.cluster = ClusterReader.read_one(reader)
10441            elif tag == 'comment':
10442                obj.comment = Reader.read_string(reader)
10443            elif tag == 'data_center':
10444                obj.data_center = DataCenterReader.read_one(reader)
10445            elif tag == 'description':
10446                obj.description = Reader.read_string(reader)
10447            elif tag == 'display':
10448                obj.display = Reader.read_boolean(reader)
10449            elif tag == 'dns_resolver_configuration':
10450                obj.dns_resolver_configuration = DnsResolverConfigurationReader.read_one(reader)
10451            elif tag == 'external_provider':
10452                obj.external_provider = OpenStackNetworkProviderReader.read_one(reader)
10453            elif tag == 'external_provider_physical_network':
10454                obj.external_provider_physical_network = NetworkReader.read_one(reader)
10455            elif tag == 'ip':
10456                obj.ip = IpReader.read_one(reader)
10457            elif tag == 'mtu':
10458                obj.mtu = Reader.read_integer(reader)
10459            elif tag == 'name':
10460                obj.name = Reader.read_string(reader)
10461            elif tag == 'network_labels':
10462                obj.network_labels = NetworkLabelReader.read_many(reader)
10463            elif tag == 'permissions':
10464                obj.permissions = PermissionReader.read_many(reader)
10465            elif tag == 'port_isolation':
10466                obj.port_isolation = Reader.read_boolean(reader)
10467            elif tag == 'profile_required':
10468                obj.profile_required = Reader.read_boolean(reader)
10469            elif tag == 'qos':
10470                obj.qos = QosReader.read_one(reader)
10471            elif tag == 'required':
10472                obj.required = Reader.read_boolean(reader)
10473            elif tag == 'status':
10474                obj.status = Reader.read_enum(types.NetworkStatus, reader)
10475            elif tag == 'stp':
10476                obj.stp = Reader.read_boolean(reader)
10477            elif tag == 'usages':
10478                obj.usages = Reader.read_enums(types.NetworkUsage, reader)
10479            elif tag == 'vdsm_name':
10480                obj.vdsm_name = Reader.read_string(reader)
10481            elif tag == 'vlan':
10482                obj.vlan = VlanReader.read_one(reader)
10483            elif tag == 'vnic_profiles':
10484                obj.vnic_profiles = VnicProfileReader.read_many(reader)
10485            elif tag == 'link':
10486                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
10487                reader.next_element()
10488            else:
10489                reader.next_element()
10490        for link in links:
10491            NetworkReader._process_link(link, obj)
10492
10493        # Discard the end tag:
10494        reader.read()
10495
10496        return obj
10497
10498    @staticmethod
10499    def read_many(reader):
10500        # Do nothing if there aren't more tags:
10501        objs = List()
10502        if not reader.forward():
10503            return objs
10504
10505        # Process the attributes:
10506        objs.href = reader.get_attribute('href')
10507
10508        # Discard the start tag:
10509        empty = reader.empty_element()
10510        reader.read()
10511        if empty:
10512            return objs
10513
10514        # Process the inner elements:
10515        while reader.forward():
10516            objs.append(NetworkReader.read_one(reader))
10517
10518        # Discard the end tag:
10519        reader.read()
10520
10521        return objs
10522
10523    @staticmethod
10524    def _process_link(link, obj):
10525        # Process the attributes:
10526        rel = link[0]
10527        href = link[1]
10528        if href and rel:
10529            if rel == "networklabels":
10530                if obj.network_labels is not None:
10531                    obj.network_labels.href = href
10532                else:
10533                    obj.network_labels = List(href)
10534            elif rel == "permissions":
10535                if obj.permissions is not None:
10536                    obj.permissions.href = href
10537                else:
10538                    obj.permissions = List(href)
10539            elif rel == "vnicprofiles":
10540                if obj.vnic_profiles is not None:
10541                    obj.vnic_profiles.href = href
10542                else:
10543                    obj.vnic_profiles = List(href)
10544
10545
10546class NetworkAttachmentReader(Reader):
10547
10548    def __init__(self):
10549        super(NetworkAttachmentReader, self).__init__()
10550
10551    @staticmethod
10552    def read_one(reader):
10553        # Do nothing if there aren't more tags:
10554        if not reader.forward():
10555            return None
10556
10557        # Create the object:
10558        obj = types.NetworkAttachment()
10559
10560        # Process the attributes:
10561        obj.href = reader.get_attribute('href')
10562        value = reader.get_attribute('id')
10563        if value is not None:
10564            obj.id = value
10565
10566        # Discard the start tag:
10567        empty = reader.empty_element()
10568        reader.read()
10569        if empty:
10570            return obj
10571
10572        # Process the inner elements:
10573        links = []
10574        while reader.forward():
10575            tag = reader.node_name()
10576            if tag == 'comment':
10577                obj.comment = Reader.read_string(reader)
10578            elif tag == 'description':
10579                obj.description = Reader.read_string(reader)
10580            elif tag == 'dns_resolver_configuration':
10581                obj.dns_resolver_configuration = DnsResolverConfigurationReader.read_one(reader)
10582            elif tag == 'host':
10583                obj.host = HostReader.read_one(reader)
10584            elif tag == 'host_nic':
10585                obj.host_nic = HostNicReader.read_one(reader)
10586            elif tag == 'in_sync':
10587                obj.in_sync = Reader.read_boolean(reader)
10588            elif tag == 'ip_address_assignments':
10589                obj.ip_address_assignments = IpAddressAssignmentReader.read_many(reader)
10590            elif tag == 'name':
10591                obj.name = Reader.read_string(reader)
10592            elif tag == 'network':
10593                obj.network = NetworkReader.read_one(reader)
10594            elif tag == 'properties':
10595                obj.properties = PropertyReader.read_many(reader)
10596            elif tag == 'qos':
10597                obj.qos = QosReader.read_one(reader)
10598            elif tag == 'reported_configurations':
10599                obj.reported_configurations = ReportedConfigurationReader.read_many(reader)
10600            else:
10601                reader.next_element()
10602        for link in links:
10603            NetworkAttachmentReader._process_link(link, obj)
10604
10605        # Discard the end tag:
10606        reader.read()
10607
10608        return obj
10609
10610    @staticmethod
10611    def read_many(reader):
10612        # Do nothing if there aren't more tags:
10613        objs = List()
10614        if not reader.forward():
10615            return objs
10616
10617        # Process the attributes:
10618        objs.href = reader.get_attribute('href')
10619
10620        # Discard the start tag:
10621        empty = reader.empty_element()
10622        reader.read()
10623        if empty:
10624            return objs
10625
10626        # Process the inner elements:
10627        while reader.forward():
10628            objs.append(NetworkAttachmentReader.read_one(reader))
10629
10630        # Discard the end tag:
10631        reader.read()
10632
10633        return objs
10634
10635
10636class NetworkConfigurationReader(Reader):
10637
10638    def __init__(self):
10639        super(NetworkConfigurationReader, self).__init__()
10640
10641    @staticmethod
10642    def read_one(reader):
10643        # Do nothing if there aren't more tags:
10644        if not reader.forward():
10645            return None
10646
10647        # Create the object:
10648        obj = types.NetworkConfiguration()
10649
10650        # Process the attributes:
10651        obj.href = reader.get_attribute('href')
10652
10653        # Discard the start tag:
10654        empty = reader.empty_element()
10655        reader.read()
10656        if empty:
10657            return obj
10658
10659        # Process the inner elements:
10660        links = []
10661        while reader.forward():
10662            tag = reader.node_name()
10663            if tag == 'dns':
10664                obj.dns = DnsReader.read_one(reader)
10665            elif tag == 'nics':
10666                obj.nics = NicReader.read_many(reader)
10667            else:
10668                reader.next_element()
10669        for link in links:
10670            NetworkConfigurationReader._process_link(link, obj)
10671
10672        # Discard the end tag:
10673        reader.read()
10674
10675        return obj
10676
10677    @staticmethod
10678    def read_many(reader):
10679        # Do nothing if there aren't more tags:
10680        objs = List()
10681        if not reader.forward():
10682            return objs
10683
10684        # Process the attributes:
10685        objs.href = reader.get_attribute('href')
10686
10687        # Discard the start tag:
10688        empty = reader.empty_element()
10689        reader.read()
10690        if empty:
10691            return objs
10692
10693        # Process the inner elements:
10694        while reader.forward():
10695            objs.append(NetworkConfigurationReader.read_one(reader))
10696
10697        # Discard the end tag:
10698        reader.read()
10699
10700        return objs
10701
10702
10703class NetworkFilterReader(Reader):
10704
10705    def __init__(self):
10706        super(NetworkFilterReader, self).__init__()
10707
10708    @staticmethod
10709    def read_one(reader):
10710        # Do nothing if there aren't more tags:
10711        if not reader.forward():
10712            return None
10713
10714        # Create the object:
10715        obj = types.NetworkFilter()
10716
10717        # Process the attributes:
10718        obj.href = reader.get_attribute('href')
10719        value = reader.get_attribute('id')
10720        if value is not None:
10721            obj.id = value
10722
10723        # Discard the start tag:
10724        empty = reader.empty_element()
10725        reader.read()
10726        if empty:
10727            return obj
10728
10729        # Process the inner elements:
10730        links = []
10731        while reader.forward():
10732            tag = reader.node_name()
10733            if tag == 'comment':
10734                obj.comment = Reader.read_string(reader)
10735            elif tag == 'description':
10736                obj.description = Reader.read_string(reader)
10737            elif tag == 'name':
10738                obj.name = Reader.read_string(reader)
10739            elif tag == 'version':
10740                obj.version = VersionReader.read_one(reader)
10741            else:
10742                reader.next_element()
10743        for link in links:
10744            NetworkFilterReader._process_link(link, obj)
10745
10746        # Discard the end tag:
10747        reader.read()
10748
10749        return obj
10750
10751    @staticmethod
10752    def read_many(reader):
10753        # Do nothing if there aren't more tags:
10754        objs = List()
10755        if not reader.forward():
10756            return objs
10757
10758        # Process the attributes:
10759        objs.href = reader.get_attribute('href')
10760
10761        # Discard the start tag:
10762        empty = reader.empty_element()
10763        reader.read()
10764        if empty:
10765            return objs
10766
10767        # Process the inner elements:
10768        while reader.forward():
10769            objs.append(NetworkFilterReader.read_one(reader))
10770
10771        # Discard the end tag:
10772        reader.read()
10773
10774        return objs
10775
10776
10777class NetworkFilterParameterReader(Reader):
10778
10779    def __init__(self):
10780        super(NetworkFilterParameterReader, self).__init__()
10781
10782    @staticmethod
10783    def read_one(reader):
10784        # Do nothing if there aren't more tags:
10785        if not reader.forward():
10786            return None
10787
10788        # Create the object:
10789        obj = types.NetworkFilterParameter()
10790
10791        # Process the attributes:
10792        obj.href = reader.get_attribute('href')
10793        value = reader.get_attribute('id')
10794        if value is not None:
10795            obj.id = value
10796
10797        # Discard the start tag:
10798        empty = reader.empty_element()
10799        reader.read()
10800        if empty:
10801            return obj
10802
10803        # Process the inner elements:
10804        links = []
10805        while reader.forward():
10806            tag = reader.node_name()
10807            if tag == 'comment':
10808                obj.comment = Reader.read_string(reader)
10809            elif tag == 'description':
10810                obj.description = Reader.read_string(reader)
10811            elif tag == 'name':
10812                obj.name = Reader.read_string(reader)
10813            elif tag == 'nic':
10814                obj.nic = NicReader.read_one(reader)
10815            elif tag == 'value':
10816                obj.value = Reader.read_string(reader)
10817            else:
10818                reader.next_element()
10819        for link in links:
10820            NetworkFilterParameterReader._process_link(link, obj)
10821
10822        # Discard the end tag:
10823        reader.read()
10824
10825        return obj
10826
10827    @staticmethod
10828    def read_many(reader):
10829        # Do nothing if there aren't more tags:
10830        objs = List()
10831        if not reader.forward():
10832            return objs
10833
10834        # Process the attributes:
10835        objs.href = reader.get_attribute('href')
10836
10837        # Discard the start tag:
10838        empty = reader.empty_element()
10839        reader.read()
10840        if empty:
10841            return objs
10842
10843        # Process the inner elements:
10844        while reader.forward():
10845            objs.append(NetworkFilterParameterReader.read_one(reader))
10846
10847        # Discard the end tag:
10848        reader.read()
10849
10850        return objs
10851
10852
10853class NetworkLabelReader(Reader):
10854
10855    def __init__(self):
10856        super(NetworkLabelReader, self).__init__()
10857
10858    @staticmethod
10859    def read_one(reader):
10860        # Do nothing if there aren't more tags:
10861        if not reader.forward():
10862            return None
10863
10864        # Create the object:
10865        obj = types.NetworkLabel()
10866
10867        # Process the attributes:
10868        obj.href = reader.get_attribute('href')
10869        value = reader.get_attribute('id')
10870        if value is not None:
10871            obj.id = value
10872
10873        # Discard the start tag:
10874        empty = reader.empty_element()
10875        reader.read()
10876        if empty:
10877            return obj
10878
10879        # Process the inner elements:
10880        links = []
10881        while reader.forward():
10882            tag = reader.node_name()
10883            if tag == 'comment':
10884                obj.comment = Reader.read_string(reader)
10885            elif tag == 'description':
10886                obj.description = Reader.read_string(reader)
10887            elif tag == 'host_nic':
10888                obj.host_nic = HostNicReader.read_one(reader)
10889            elif tag == 'name':
10890                obj.name = Reader.read_string(reader)
10891            elif tag == 'network':
10892                obj.network = NetworkReader.read_one(reader)
10893            else:
10894                reader.next_element()
10895        for link in links:
10896            NetworkLabelReader._process_link(link, obj)
10897
10898        # Discard the end tag:
10899        reader.read()
10900
10901        return obj
10902
10903    @staticmethod
10904    def read_many(reader):
10905        # Do nothing if there aren't more tags:
10906        objs = List()
10907        if not reader.forward():
10908            return objs
10909
10910        # Process the attributes:
10911        objs.href = reader.get_attribute('href')
10912
10913        # Discard the start tag:
10914        empty = reader.empty_element()
10915        reader.read()
10916        if empty:
10917            return objs
10918
10919        # Process the inner elements:
10920        while reader.forward():
10921            objs.append(NetworkLabelReader.read_one(reader))
10922
10923        # Discard the end tag:
10924        reader.read()
10925
10926        return objs
10927
10928
10929class NfsProfileDetailReader(Reader):
10930
10931    def __init__(self):
10932        super(NfsProfileDetailReader, self).__init__()
10933
10934    @staticmethod
10935    def read_one(reader):
10936        # Do nothing if there aren't more tags:
10937        if not reader.forward():
10938            return None
10939
10940        # Create the object:
10941        obj = types.NfsProfileDetail()
10942
10943        # Process the attributes:
10944        obj.href = reader.get_attribute('href')
10945
10946        # Discard the start tag:
10947        empty = reader.empty_element()
10948        reader.read()
10949        if empty:
10950            return obj
10951
10952        # Process the inner elements:
10953        links = []
10954        while reader.forward():
10955            tag = reader.node_name()
10956            if tag == 'nfs_server_ip':
10957                obj.nfs_server_ip = Reader.read_string(reader)
10958            elif tag == 'profile_details':
10959                obj.profile_details = ProfileDetailReader.read_many(reader)
10960            else:
10961                reader.next_element()
10962        for link in links:
10963            NfsProfileDetailReader._process_link(link, obj)
10964
10965        # Discard the end tag:
10966        reader.read()
10967
10968        return obj
10969
10970    @staticmethod
10971    def read_many(reader):
10972        # Do nothing if there aren't more tags:
10973        objs = List()
10974        if not reader.forward():
10975            return objs
10976
10977        # Process the attributes:
10978        objs.href = reader.get_attribute('href')
10979
10980        # Discard the start tag:
10981        empty = reader.empty_element()
10982        reader.read()
10983        if empty:
10984            return objs
10985
10986        # Process the inner elements:
10987        while reader.forward():
10988            objs.append(NfsProfileDetailReader.read_one(reader))
10989
10990        # Discard the end tag:
10991        reader.read()
10992
10993        return objs
10994
10995
10996class NicReader(Reader):
10997
10998    def __init__(self):
10999        super(NicReader, self).__init__()
11000
11001    @staticmethod
11002    def read_one(reader):
11003        # Do nothing if there aren't more tags:
11004        if not reader.forward():
11005            return None
11006
11007        # Create the object:
11008        obj = types.Nic()
11009
11010        # Process the attributes:
11011        obj.href = reader.get_attribute('href')
11012        value = reader.get_attribute('id')
11013        if value is not None:
11014            obj.id = value
11015
11016        # Discard the start tag:
11017        empty = reader.empty_element()
11018        reader.read()
11019        if empty:
11020            return obj
11021
11022        # Process the inner elements:
11023        links = []
11024        while reader.forward():
11025            tag = reader.node_name()
11026            if tag == 'boot_protocol':
11027                obj.boot_protocol = Reader.read_enum(types.BootProtocol, reader)
11028            elif tag == 'comment':
11029                obj.comment = Reader.read_string(reader)
11030            elif tag == 'description':
11031                obj.description = Reader.read_string(reader)
11032            elif tag == 'instance_type':
11033                obj.instance_type = InstanceTypeReader.read_one(reader)
11034            elif tag == 'interface':
11035                obj.interface = Reader.read_enum(types.NicInterface, reader)
11036            elif tag == 'linked':
11037                obj.linked = Reader.read_boolean(reader)
11038            elif tag == 'mac':
11039                obj.mac = MacReader.read_one(reader)
11040            elif tag == 'name':
11041                obj.name = Reader.read_string(reader)
11042            elif tag == 'network':
11043                obj.network = NetworkReader.read_one(reader)
11044            elif tag == 'network_attachments':
11045                obj.network_attachments = NetworkAttachmentReader.read_many(reader)
11046            elif tag == 'network_filter_parameters':
11047                obj.network_filter_parameters = NetworkFilterParameterReader.read_many(reader)
11048            elif tag == 'network_labels':
11049                obj.network_labels = NetworkLabelReader.read_many(reader)
11050            elif tag == 'on_boot':
11051                obj.on_boot = Reader.read_boolean(reader)
11052            elif tag == 'plugged':
11053                obj.plugged = Reader.read_boolean(reader)
11054            elif tag == 'reported_devices':
11055                obj.reported_devices = ReportedDeviceReader.read_many(reader)
11056            elif tag == 'statistics':
11057                obj.statistics = StatisticReader.read_many(reader)
11058            elif tag == 'synced':
11059                obj.synced = Reader.read_boolean(reader)
11060            elif tag == 'template':
11061                obj.template = TemplateReader.read_one(reader)
11062            elif tag == 'virtual_function_allowed_labels':
11063                obj.virtual_function_allowed_labels = NetworkLabelReader.read_many(reader)
11064            elif tag == 'virtual_function_allowed_networks':
11065                obj.virtual_function_allowed_networks = NetworkReader.read_many(reader)
11066            elif tag == 'vm':
11067                obj.vm = VmReader.read_one(reader)
11068            elif tag == 'vms':
11069                obj.vms = VmReader.read_many(reader)
11070            elif tag == 'vnic_profile':
11071                obj.vnic_profile = VnicProfileReader.read_one(reader)
11072            elif tag == 'link':
11073                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
11074                reader.next_element()
11075            else:
11076                reader.next_element()
11077        for link in links:
11078            NicReader._process_link(link, obj)
11079
11080        # Discard the end tag:
11081        reader.read()
11082
11083        return obj
11084
11085    @staticmethod
11086    def read_many(reader):
11087        # Do nothing if there aren't more tags:
11088        objs = List()
11089        if not reader.forward():
11090            return objs
11091
11092        # Process the attributes:
11093        objs.href = reader.get_attribute('href')
11094
11095        # Discard the start tag:
11096        empty = reader.empty_element()
11097        reader.read()
11098        if empty:
11099            return objs
11100
11101        # Process the inner elements:
11102        while reader.forward():
11103            objs.append(NicReader.read_one(reader))
11104
11105        # Discard the end tag:
11106        reader.read()
11107
11108        return objs
11109
11110    @staticmethod
11111    def _process_link(link, obj):
11112        # Process the attributes:
11113        rel = link[0]
11114        href = link[1]
11115        if href and rel:
11116            if rel == "networkattachments":
11117                if obj.network_attachments is not None:
11118                    obj.network_attachments.href = href
11119                else:
11120                    obj.network_attachments = List(href)
11121            elif rel == "networkfilterparameters":
11122                if obj.network_filter_parameters is not None:
11123                    obj.network_filter_parameters.href = href
11124                else:
11125                    obj.network_filter_parameters = List(href)
11126            elif rel == "networklabels":
11127                if obj.network_labels is not None:
11128                    obj.network_labels.href = href
11129                else:
11130                    obj.network_labels = List(href)
11131            elif rel == "reporteddevices":
11132                if obj.reported_devices is not None:
11133                    obj.reported_devices.href = href
11134                else:
11135                    obj.reported_devices = List(href)
11136            elif rel == "statistics":
11137                if obj.statistics is not None:
11138                    obj.statistics.href = href
11139                else:
11140                    obj.statistics = List(href)
11141            elif rel == "virtualfunctionallowedlabels":
11142                if obj.virtual_function_allowed_labels is not None:
11143                    obj.virtual_function_allowed_labels.href = href
11144                else:
11145                    obj.virtual_function_allowed_labels = List(href)
11146            elif rel == "virtualfunctionallowednetworks":
11147                if obj.virtual_function_allowed_networks is not None:
11148                    obj.virtual_function_allowed_networks.href = href
11149                else:
11150                    obj.virtual_function_allowed_networks = List(href)
11151            elif rel == "vms":
11152                if obj.vms is not None:
11153                    obj.vms.href = href
11154                else:
11155                    obj.vms = List(href)
11156
11157
11158class NicConfigurationReader(Reader):
11159
11160    def __init__(self):
11161        super(NicConfigurationReader, self).__init__()
11162
11163    @staticmethod
11164    def read_one(reader):
11165        # Do nothing if there aren't more tags:
11166        if not reader.forward():
11167            return None
11168
11169        # Create the object:
11170        obj = types.NicConfiguration()
11171
11172        # Process the attributes:
11173        obj.href = reader.get_attribute('href')
11174
11175        # Discard the start tag:
11176        empty = reader.empty_element()
11177        reader.read()
11178        if empty:
11179            return obj
11180
11181        # Process the inner elements:
11182        links = []
11183        while reader.forward():
11184            tag = reader.node_name()
11185            if tag == 'boot_protocol':
11186                obj.boot_protocol = Reader.read_enum(types.BootProtocol, reader)
11187            elif tag == 'ip':
11188                obj.ip = IpReader.read_one(reader)
11189            elif tag == 'ipv6':
11190                obj.ipv6 = IpReader.read_one(reader)
11191            elif tag == 'ipv6_boot_protocol':
11192                obj.ipv6_boot_protocol = Reader.read_enum(types.BootProtocol, reader)
11193            elif tag == 'name':
11194                obj.name = Reader.read_string(reader)
11195            elif tag == 'on_boot':
11196                obj.on_boot = Reader.read_boolean(reader)
11197            else:
11198                reader.next_element()
11199        for link in links:
11200            NicConfigurationReader._process_link(link, obj)
11201
11202        # Discard the end tag:
11203        reader.read()
11204
11205        return obj
11206
11207    @staticmethod
11208    def read_many(reader):
11209        # Do nothing if there aren't more tags:
11210        objs = List()
11211        if not reader.forward():
11212            return objs
11213
11214        # Process the attributes:
11215        objs.href = reader.get_attribute('href')
11216
11217        # Discard the start tag:
11218        empty = reader.empty_element()
11219        reader.read()
11220        if empty:
11221            return objs
11222
11223        # Process the inner elements:
11224        while reader.forward():
11225            objs.append(NicConfigurationReader.read_one(reader))
11226
11227        # Discard the end tag:
11228        reader.read()
11229
11230        return objs
11231
11232
11233class NumaNodeReader(Reader):
11234
11235    def __init__(self):
11236        super(NumaNodeReader, self).__init__()
11237
11238    @staticmethod
11239    def read_one(reader):
11240        # Do nothing if there aren't more tags:
11241        if not reader.forward():
11242            return None
11243
11244        # Create the object:
11245        obj = types.NumaNode()
11246
11247        # Process the attributes:
11248        obj.href = reader.get_attribute('href')
11249        value = reader.get_attribute('id')
11250        if value is not None:
11251            obj.id = value
11252
11253        # Discard the start tag:
11254        empty = reader.empty_element()
11255        reader.read()
11256        if empty:
11257            return obj
11258
11259        # Process the inner elements:
11260        links = []
11261        while reader.forward():
11262            tag = reader.node_name()
11263            if tag == 'comment':
11264                obj.comment = Reader.read_string(reader)
11265            elif tag == 'cpu':
11266                obj.cpu = CpuReader.read_one(reader)
11267            elif tag == 'description':
11268                obj.description = Reader.read_string(reader)
11269            elif tag == 'host':
11270                obj.host = HostReader.read_one(reader)
11271            elif tag == 'index':
11272                obj.index = Reader.read_integer(reader)
11273            elif tag == 'memory':
11274                obj.memory = Reader.read_integer(reader)
11275            elif tag == 'name':
11276                obj.name = Reader.read_string(reader)
11277            elif tag == 'node_distance':
11278                obj.node_distance = Reader.read_string(reader)
11279            elif tag == 'statistics':
11280                obj.statistics = StatisticReader.read_many(reader)
11281            elif tag == 'link':
11282                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
11283                reader.next_element()
11284            else:
11285                reader.next_element()
11286        for link in links:
11287            NumaNodeReader._process_link(link, obj)
11288
11289        # Discard the end tag:
11290        reader.read()
11291
11292        return obj
11293
11294    @staticmethod
11295    def read_many(reader):
11296        # Do nothing if there aren't more tags:
11297        objs = List()
11298        if not reader.forward():
11299            return objs
11300
11301        # Process the attributes:
11302        objs.href = reader.get_attribute('href')
11303
11304        # Discard the start tag:
11305        empty = reader.empty_element()
11306        reader.read()
11307        if empty:
11308            return objs
11309
11310        # Process the inner elements:
11311        while reader.forward():
11312            objs.append(NumaNodeReader.read_one(reader))
11313
11314        # Discard the end tag:
11315        reader.read()
11316
11317        return objs
11318
11319    @staticmethod
11320    def _process_link(link, obj):
11321        # Process the attributes:
11322        rel = link[0]
11323        href = link[1]
11324        if href and rel:
11325            if rel == "statistics":
11326                if obj.statistics is not None:
11327                    obj.statistics.href = href
11328                else:
11329                    obj.statistics = List(href)
11330
11331
11332class NumaNodePinReader(Reader):
11333
11334    def __init__(self):
11335        super(NumaNodePinReader, self).__init__()
11336
11337    @staticmethod
11338    def read_one(reader):
11339        # Do nothing if there aren't more tags:
11340        if not reader.forward():
11341            return None
11342
11343        # Create the object:
11344        obj = types.NumaNodePin()
11345
11346        # Process the attributes:
11347        obj.href = reader.get_attribute('href')
11348
11349        # Discard the start tag:
11350        empty = reader.empty_element()
11351        reader.read()
11352        if empty:
11353            return obj
11354
11355        # Process the inner elements:
11356        links = []
11357        while reader.forward():
11358            tag = reader.node_name()
11359            if tag == 'host_numa_node':
11360                obj.host_numa_node = NumaNodeReader.read_one(reader)
11361            elif tag == 'index':
11362                obj.index = Reader.read_integer(reader)
11363            elif tag == 'pinned':
11364                obj.pinned = Reader.read_boolean(reader)
11365            else:
11366                reader.next_element()
11367        for link in links:
11368            NumaNodePinReader._process_link(link, obj)
11369
11370        # Discard the end tag:
11371        reader.read()
11372
11373        return obj
11374
11375    @staticmethod
11376    def read_many(reader):
11377        # Do nothing if there aren't more tags:
11378        objs = List()
11379        if not reader.forward():
11380            return objs
11381
11382        # Process the attributes:
11383        objs.href = reader.get_attribute('href')
11384
11385        # Discard the start tag:
11386        empty = reader.empty_element()
11387        reader.read()
11388        if empty:
11389            return objs
11390
11391        # Process the inner elements:
11392        while reader.forward():
11393            objs.append(NumaNodePinReader.read_one(reader))
11394
11395        # Discard the end tag:
11396        reader.read()
11397
11398        return objs
11399
11400
11401class OpenStackImageReader(Reader):
11402
11403    def __init__(self):
11404        super(OpenStackImageReader, self).__init__()
11405
11406    @staticmethod
11407    def read_one(reader):
11408        # Do nothing if there aren't more tags:
11409        if not reader.forward():
11410            return None
11411
11412        # Create the object:
11413        obj = types.OpenStackImage()
11414
11415        # Process the attributes:
11416        obj.href = reader.get_attribute('href')
11417        value = reader.get_attribute('id')
11418        if value is not None:
11419            obj.id = value
11420
11421        # Discard the start tag:
11422        empty = reader.empty_element()
11423        reader.read()
11424        if empty:
11425            return obj
11426
11427        # Process the inner elements:
11428        links = []
11429        while reader.forward():
11430            tag = reader.node_name()
11431            if tag == 'comment':
11432                obj.comment = Reader.read_string(reader)
11433            elif tag == 'description':
11434                obj.description = Reader.read_string(reader)
11435            elif tag == 'name':
11436                obj.name = Reader.read_string(reader)
11437            elif tag == 'openstack_image_provider':
11438                obj.openstack_image_provider = OpenStackImageProviderReader.read_one(reader)
11439            else:
11440                reader.next_element()
11441        for link in links:
11442            OpenStackImageReader._process_link(link, obj)
11443
11444        # Discard the end tag:
11445        reader.read()
11446
11447        return obj
11448
11449    @staticmethod
11450    def read_many(reader):
11451        # Do nothing if there aren't more tags:
11452        objs = List()
11453        if not reader.forward():
11454            return objs
11455
11456        # Process the attributes:
11457        objs.href = reader.get_attribute('href')
11458
11459        # Discard the start tag:
11460        empty = reader.empty_element()
11461        reader.read()
11462        if empty:
11463            return objs
11464
11465        # Process the inner elements:
11466        while reader.forward():
11467            objs.append(OpenStackImageReader.read_one(reader))
11468
11469        # Discard the end tag:
11470        reader.read()
11471
11472        return objs
11473
11474
11475class OpenStackImageProviderReader(Reader):
11476
11477    def __init__(self):
11478        super(OpenStackImageProviderReader, self).__init__()
11479
11480    @staticmethod
11481    def read_one(reader):
11482        # Do nothing if there aren't more tags:
11483        if not reader.forward():
11484            return None
11485
11486        # Create the object:
11487        obj = types.OpenStackImageProvider()
11488
11489        # Process the attributes:
11490        obj.href = reader.get_attribute('href')
11491        value = reader.get_attribute('id')
11492        if value is not None:
11493            obj.id = value
11494
11495        # Discard the start tag:
11496        empty = reader.empty_element()
11497        reader.read()
11498        if empty:
11499            return obj
11500
11501        # Process the inner elements:
11502        links = []
11503        while reader.forward():
11504            tag = reader.node_name()
11505            if tag == 'authentication_url':
11506                obj.authentication_url = Reader.read_string(reader)
11507            elif tag == 'certificates':
11508                obj.certificates = CertificateReader.read_many(reader)
11509            elif tag == 'comment':
11510                obj.comment = Reader.read_string(reader)
11511            elif tag == 'description':
11512                obj.description = Reader.read_string(reader)
11513            elif tag == 'images':
11514                obj.images = OpenStackImageReader.read_many(reader)
11515            elif tag == 'name':
11516                obj.name = Reader.read_string(reader)
11517            elif tag == 'password':
11518                obj.password = Reader.read_string(reader)
11519            elif tag == 'properties':
11520                obj.properties = PropertyReader.read_many(reader)
11521            elif tag == 'requires_authentication':
11522                obj.requires_authentication = Reader.read_boolean(reader)
11523            elif tag == 'tenant_name':
11524                obj.tenant_name = Reader.read_string(reader)
11525            elif tag == 'url':
11526                obj.url = Reader.read_string(reader)
11527            elif tag == 'username':
11528                obj.username = Reader.read_string(reader)
11529            elif tag == 'link':
11530                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
11531                reader.next_element()
11532            else:
11533                reader.next_element()
11534        for link in links:
11535            OpenStackImageProviderReader._process_link(link, obj)
11536
11537        # Discard the end tag:
11538        reader.read()
11539
11540        return obj
11541
11542    @staticmethod
11543    def read_many(reader):
11544        # Do nothing if there aren't more tags:
11545        objs = List()
11546        if not reader.forward():
11547            return objs
11548
11549        # Process the attributes:
11550        objs.href = reader.get_attribute('href')
11551
11552        # Discard the start tag:
11553        empty = reader.empty_element()
11554        reader.read()
11555        if empty:
11556            return objs
11557
11558        # Process the inner elements:
11559        while reader.forward():
11560            objs.append(OpenStackImageProviderReader.read_one(reader))
11561
11562        # Discard the end tag:
11563        reader.read()
11564
11565        return objs
11566
11567    @staticmethod
11568    def _process_link(link, obj):
11569        # Process the attributes:
11570        rel = link[0]
11571        href = link[1]
11572        if href and rel:
11573            if rel == "certificates":
11574                if obj.certificates is not None:
11575                    obj.certificates.href = href
11576                else:
11577                    obj.certificates = List(href)
11578            elif rel == "images":
11579                if obj.images is not None:
11580                    obj.images.href = href
11581                else:
11582                    obj.images = List(href)
11583
11584
11585class OpenStackNetworkReader(Reader):
11586
11587    def __init__(self):
11588        super(OpenStackNetworkReader, self).__init__()
11589
11590    @staticmethod
11591    def read_one(reader):
11592        # Do nothing if there aren't more tags:
11593        if not reader.forward():
11594            return None
11595
11596        # Create the object:
11597        obj = types.OpenStackNetwork()
11598
11599        # Process the attributes:
11600        obj.href = reader.get_attribute('href')
11601        value = reader.get_attribute('id')
11602        if value is not None:
11603            obj.id = value
11604
11605        # Discard the start tag:
11606        empty = reader.empty_element()
11607        reader.read()
11608        if empty:
11609            return obj
11610
11611        # Process the inner elements:
11612        links = []
11613        while reader.forward():
11614            tag = reader.node_name()
11615            if tag == 'comment':
11616                obj.comment = Reader.read_string(reader)
11617            elif tag == 'description':
11618                obj.description = Reader.read_string(reader)
11619            elif tag == 'name':
11620                obj.name = Reader.read_string(reader)
11621            elif tag == 'openstack_network_provider':
11622                obj.openstack_network_provider = OpenStackNetworkProviderReader.read_one(reader)
11623            else:
11624                reader.next_element()
11625        for link in links:
11626            OpenStackNetworkReader._process_link(link, obj)
11627
11628        # Discard the end tag:
11629        reader.read()
11630
11631        return obj
11632
11633    @staticmethod
11634    def read_many(reader):
11635        # Do nothing if there aren't more tags:
11636        objs = List()
11637        if not reader.forward():
11638            return objs
11639
11640        # Process the attributes:
11641        objs.href = reader.get_attribute('href')
11642
11643        # Discard the start tag:
11644        empty = reader.empty_element()
11645        reader.read()
11646        if empty:
11647            return objs
11648
11649        # Process the inner elements:
11650        while reader.forward():
11651            objs.append(OpenStackNetworkReader.read_one(reader))
11652
11653        # Discard the end tag:
11654        reader.read()
11655
11656        return objs
11657
11658
11659class OpenStackNetworkProviderReader(Reader):
11660
11661    def __init__(self):
11662        super(OpenStackNetworkProviderReader, self).__init__()
11663
11664    @staticmethod
11665    def read_one(reader):
11666        # Do nothing if there aren't more tags:
11667        if not reader.forward():
11668            return None
11669
11670        # Create the object:
11671        obj = types.OpenStackNetworkProvider()
11672
11673        # Process the attributes:
11674        obj.href = reader.get_attribute('href')
11675        value = reader.get_attribute('id')
11676        if value is not None:
11677            obj.id = value
11678
11679        # Discard the start tag:
11680        empty = reader.empty_element()
11681        reader.read()
11682        if empty:
11683            return obj
11684
11685        # Process the inner elements:
11686        links = []
11687        while reader.forward():
11688            tag = reader.node_name()
11689            if tag == 'agent_configuration':
11690                obj.agent_configuration = AgentConfigurationReader.read_one(reader)
11691            elif tag == 'authentication_url':
11692                obj.authentication_url = Reader.read_string(reader)
11693            elif tag == 'auto_sync':
11694                obj.auto_sync = Reader.read_boolean(reader)
11695            elif tag == 'certificates':
11696                obj.certificates = CertificateReader.read_many(reader)
11697            elif tag == 'comment':
11698                obj.comment = Reader.read_string(reader)
11699            elif tag == 'description':
11700                obj.description = Reader.read_string(reader)
11701            elif tag == 'external_plugin_type':
11702                obj.external_plugin_type = Reader.read_string(reader)
11703            elif tag == 'name':
11704                obj.name = Reader.read_string(reader)
11705            elif tag == 'networks':
11706                obj.networks = OpenStackNetworkReader.read_many(reader)
11707            elif tag == 'password':
11708                obj.password = Reader.read_string(reader)
11709            elif tag == 'plugin_type':
11710                obj.plugin_type = Reader.read_enum(types.NetworkPluginType, reader)
11711            elif tag == 'project_domain_name':
11712                obj.project_domain_name = Reader.read_string(reader)
11713            elif tag == 'project_name':
11714                obj.project_name = Reader.read_string(reader)
11715            elif tag == 'properties':
11716                obj.properties = PropertyReader.read_many(reader)
11717            elif tag == 'read_only':
11718                obj.read_only = Reader.read_boolean(reader)
11719            elif tag == 'requires_authentication':
11720                obj.requires_authentication = Reader.read_boolean(reader)
11721            elif tag == 'subnets':
11722                obj.subnets = OpenStackSubnetReader.read_many(reader)
11723            elif tag == 'tenant_name':
11724                obj.tenant_name = Reader.read_string(reader)
11725            elif tag == 'type':
11726                obj.type = Reader.read_enum(types.OpenStackNetworkProviderType, reader)
11727            elif tag == 'unmanaged':
11728                obj.unmanaged = Reader.read_boolean(reader)
11729            elif tag == 'url':
11730                obj.url = Reader.read_string(reader)
11731            elif tag == 'user_domain_name':
11732                obj.user_domain_name = Reader.read_string(reader)
11733            elif tag == 'username':
11734                obj.username = Reader.read_string(reader)
11735            elif tag == 'link':
11736                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
11737                reader.next_element()
11738            else:
11739                reader.next_element()
11740        for link in links:
11741            OpenStackNetworkProviderReader._process_link(link, obj)
11742
11743        # Discard the end tag:
11744        reader.read()
11745
11746        return obj
11747
11748    @staticmethod
11749    def read_many(reader):
11750        # Do nothing if there aren't more tags:
11751        objs = List()
11752        if not reader.forward():
11753            return objs
11754
11755        # Process the attributes:
11756        objs.href = reader.get_attribute('href')
11757
11758        # Discard the start tag:
11759        empty = reader.empty_element()
11760        reader.read()
11761        if empty:
11762            return objs
11763
11764        # Process the inner elements:
11765        while reader.forward():
11766            objs.append(OpenStackNetworkProviderReader.read_one(reader))
11767
11768        # Discard the end tag:
11769        reader.read()
11770
11771        return objs
11772
11773    @staticmethod
11774    def _process_link(link, obj):
11775        # Process the attributes:
11776        rel = link[0]
11777        href = link[1]
11778        if href and rel:
11779            if rel == "certificates":
11780                if obj.certificates is not None:
11781                    obj.certificates.href = href
11782                else:
11783                    obj.certificates = List(href)
11784            elif rel == "networks":
11785                if obj.networks is not None:
11786                    obj.networks.href = href
11787                else:
11788                    obj.networks = List(href)
11789            elif rel == "subnets":
11790                if obj.subnets is not None:
11791                    obj.subnets.href = href
11792                else:
11793                    obj.subnets = List(href)
11794
11795
11796class OpenStackProviderReader(Reader):
11797
11798    def __init__(self):
11799        super(OpenStackProviderReader, self).__init__()
11800
11801    @staticmethod
11802    def read_one(reader):
11803        # Do nothing if there aren't more tags:
11804        if not reader.forward():
11805            return None
11806
11807        # Create the object:
11808        obj = types.OpenStackProvider()
11809
11810        # Process the attributes:
11811        obj.href = reader.get_attribute('href')
11812        value = reader.get_attribute('id')
11813        if value is not None:
11814            obj.id = value
11815
11816        # Discard the start tag:
11817        empty = reader.empty_element()
11818        reader.read()
11819        if empty:
11820            return obj
11821
11822        # Process the inner elements:
11823        links = []
11824        while reader.forward():
11825            tag = reader.node_name()
11826            if tag == 'authentication_url':
11827                obj.authentication_url = Reader.read_string(reader)
11828            elif tag == 'comment':
11829                obj.comment = Reader.read_string(reader)
11830            elif tag == 'description':
11831                obj.description = Reader.read_string(reader)
11832            elif tag == 'name':
11833                obj.name = Reader.read_string(reader)
11834            elif tag == 'password':
11835                obj.password = Reader.read_string(reader)
11836            elif tag == 'properties':
11837                obj.properties = PropertyReader.read_many(reader)
11838            elif tag == 'requires_authentication':
11839                obj.requires_authentication = Reader.read_boolean(reader)
11840            elif tag == 'tenant_name':
11841                obj.tenant_name = Reader.read_string(reader)
11842            elif tag == 'url':
11843                obj.url = Reader.read_string(reader)
11844            elif tag == 'username':
11845                obj.username = Reader.read_string(reader)
11846            else:
11847                reader.next_element()
11848        for link in links:
11849            OpenStackProviderReader._process_link(link, obj)
11850
11851        # Discard the end tag:
11852        reader.read()
11853
11854        return obj
11855
11856    @staticmethod
11857    def read_many(reader):
11858        # Do nothing if there aren't more tags:
11859        objs = List()
11860        if not reader.forward():
11861            return objs
11862
11863        # Process the attributes:
11864        objs.href = reader.get_attribute('href')
11865
11866        # Discard the start tag:
11867        empty = reader.empty_element()
11868        reader.read()
11869        if empty:
11870            return objs
11871
11872        # Process the inner elements:
11873        while reader.forward():
11874            objs.append(OpenStackProviderReader.read_one(reader))
11875
11876        # Discard the end tag:
11877        reader.read()
11878
11879        return objs
11880
11881
11882class OpenStackSubnetReader(Reader):
11883
11884    def __init__(self):
11885        super(OpenStackSubnetReader, self).__init__()
11886
11887    @staticmethod
11888    def read_one(reader):
11889        # Do nothing if there aren't more tags:
11890        if not reader.forward():
11891            return None
11892
11893        # Create the object:
11894        obj = types.OpenStackSubnet()
11895
11896        # Process the attributes:
11897        obj.href = reader.get_attribute('href')
11898        value = reader.get_attribute('id')
11899        if value is not None:
11900            obj.id = value
11901
11902        # Discard the start tag:
11903        empty = reader.empty_element()
11904        reader.read()
11905        if empty:
11906            return obj
11907
11908        # Process the inner elements:
11909        links = []
11910        while reader.forward():
11911            tag = reader.node_name()
11912            if tag == 'cidr':
11913                obj.cidr = Reader.read_string(reader)
11914            elif tag == 'comment':
11915                obj.comment = Reader.read_string(reader)
11916            elif tag == 'description':
11917                obj.description = Reader.read_string(reader)
11918            elif tag == 'dns_servers':
11919                obj.dns_servers = Reader.read_strings(reader)
11920            elif tag == 'gateway':
11921                obj.gateway = Reader.read_string(reader)
11922            elif tag == 'ip_version':
11923                obj.ip_version = Reader.read_string(reader)
11924            elif tag == 'name':
11925                obj.name = Reader.read_string(reader)
11926            elif tag == 'openstack_network':
11927                obj.openstack_network = OpenStackNetworkReader.read_one(reader)
11928            else:
11929                reader.next_element()
11930        for link in links:
11931            OpenStackSubnetReader._process_link(link, obj)
11932
11933        # Discard the end tag:
11934        reader.read()
11935
11936        return obj
11937
11938    @staticmethod
11939    def read_many(reader):
11940        # Do nothing if there aren't more tags:
11941        objs = List()
11942        if not reader.forward():
11943            return objs
11944
11945        # Process the attributes:
11946        objs.href = reader.get_attribute('href')
11947
11948        # Discard the start tag:
11949        empty = reader.empty_element()
11950        reader.read()
11951        if empty:
11952            return objs
11953
11954        # Process the inner elements:
11955        while reader.forward():
11956            objs.append(OpenStackSubnetReader.read_one(reader))
11957
11958        # Discard the end tag:
11959        reader.read()
11960
11961        return objs
11962
11963
11964class OpenStackVolumeProviderReader(Reader):
11965
11966    def __init__(self):
11967        super(OpenStackVolumeProviderReader, self).__init__()
11968
11969    @staticmethod
11970    def read_one(reader):
11971        # Do nothing if there aren't more tags:
11972        if not reader.forward():
11973            return None
11974
11975        # Create the object:
11976        obj = types.OpenStackVolumeProvider()
11977
11978        # Process the attributes:
11979        obj.href = reader.get_attribute('href')
11980        value = reader.get_attribute('id')
11981        if value is not None:
11982            obj.id = value
11983
11984        # Discard the start tag:
11985        empty = reader.empty_element()
11986        reader.read()
11987        if empty:
11988            return obj
11989
11990        # Process the inner elements:
11991        links = []
11992        while reader.forward():
11993            tag = reader.node_name()
11994            if tag == 'authentication_keys':
11995                obj.authentication_keys = OpenstackVolumeAuthenticationKeyReader.read_many(reader)
11996            elif tag == 'authentication_url':
11997                obj.authentication_url = Reader.read_string(reader)
11998            elif tag == 'certificates':
11999                obj.certificates = CertificateReader.read_many(reader)
12000            elif tag == 'comment':
12001                obj.comment = Reader.read_string(reader)
12002            elif tag == 'data_center':
12003                obj.data_center = DataCenterReader.read_one(reader)
12004            elif tag == 'description':
12005                obj.description = Reader.read_string(reader)
12006            elif tag == 'name':
12007                obj.name = Reader.read_string(reader)
12008            elif tag == 'password':
12009                obj.password = Reader.read_string(reader)
12010            elif tag == 'properties':
12011                obj.properties = PropertyReader.read_many(reader)
12012            elif tag == 'requires_authentication':
12013                obj.requires_authentication = Reader.read_boolean(reader)
12014            elif tag == 'tenant_name':
12015                obj.tenant_name = Reader.read_string(reader)
12016            elif tag == 'url':
12017                obj.url = Reader.read_string(reader)
12018            elif tag == 'username':
12019                obj.username = Reader.read_string(reader)
12020            elif tag == 'volume_types':
12021                obj.volume_types = OpenStackVolumeTypeReader.read_many(reader)
12022            elif tag == 'link':
12023                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
12024                reader.next_element()
12025            else:
12026                reader.next_element()
12027        for link in links:
12028            OpenStackVolumeProviderReader._process_link(link, obj)
12029
12030        # Discard the end tag:
12031        reader.read()
12032
12033        return obj
12034
12035    @staticmethod
12036    def read_many(reader):
12037        # Do nothing if there aren't more tags:
12038        objs = List()
12039        if not reader.forward():
12040            return objs
12041
12042        # Process the attributes:
12043        objs.href = reader.get_attribute('href')
12044
12045        # Discard the start tag:
12046        empty = reader.empty_element()
12047        reader.read()
12048        if empty:
12049            return objs
12050
12051        # Process the inner elements:
12052        while reader.forward():
12053            objs.append(OpenStackVolumeProviderReader.read_one(reader))
12054
12055        # Discard the end tag:
12056        reader.read()
12057
12058        return objs
12059
12060    @staticmethod
12061    def _process_link(link, obj):
12062        # Process the attributes:
12063        rel = link[0]
12064        href = link[1]
12065        if href and rel:
12066            if rel == "authenticationkeys":
12067                if obj.authentication_keys is not None:
12068                    obj.authentication_keys.href = href
12069                else:
12070                    obj.authentication_keys = List(href)
12071            elif rel == "certificates":
12072                if obj.certificates is not None:
12073                    obj.certificates.href = href
12074                else:
12075                    obj.certificates = List(href)
12076            elif rel == "volumetypes":
12077                if obj.volume_types is not None:
12078                    obj.volume_types.href = href
12079                else:
12080                    obj.volume_types = List(href)
12081
12082
12083class OpenStackVolumeTypeReader(Reader):
12084
12085    def __init__(self):
12086        super(OpenStackVolumeTypeReader, self).__init__()
12087
12088    @staticmethod
12089    def read_one(reader):
12090        # Do nothing if there aren't more tags:
12091        if not reader.forward():
12092            return None
12093
12094        # Create the object:
12095        obj = types.OpenStackVolumeType()
12096
12097        # Process the attributes:
12098        obj.href = reader.get_attribute('href')
12099        value = reader.get_attribute('id')
12100        if value is not None:
12101            obj.id = value
12102
12103        # Discard the start tag:
12104        empty = reader.empty_element()
12105        reader.read()
12106        if empty:
12107            return obj
12108
12109        # Process the inner elements:
12110        links = []
12111        while reader.forward():
12112            tag = reader.node_name()
12113            if tag == 'comment':
12114                obj.comment = Reader.read_string(reader)
12115            elif tag == 'description':
12116                obj.description = Reader.read_string(reader)
12117            elif tag == 'name':
12118                obj.name = Reader.read_string(reader)
12119            elif tag == 'openstack_volume_provider':
12120                obj.openstack_volume_provider = OpenStackVolumeProviderReader.read_one(reader)
12121            elif tag == 'properties':
12122                obj.properties = PropertyReader.read_many(reader)
12123            else:
12124                reader.next_element()
12125        for link in links:
12126            OpenStackVolumeTypeReader._process_link(link, obj)
12127
12128        # Discard the end tag:
12129        reader.read()
12130
12131        return obj
12132
12133    @staticmethod
12134    def read_many(reader):
12135        # Do nothing if there aren't more tags:
12136        objs = List()
12137        if not reader.forward():
12138            return objs
12139
12140        # Process the attributes:
12141        objs.href = reader.get_attribute('href')
12142
12143        # Discard the start tag:
12144        empty = reader.empty_element()
12145        reader.read()
12146        if empty:
12147            return objs
12148
12149        # Process the inner elements:
12150        while reader.forward():
12151            objs.append(OpenStackVolumeTypeReader.read_one(reader))
12152
12153        # Discard the end tag:
12154        reader.read()
12155
12156        return objs
12157
12158
12159class OpenstackVolumeAuthenticationKeyReader(Reader):
12160
12161    def __init__(self):
12162        super(OpenstackVolumeAuthenticationKeyReader, self).__init__()
12163
12164    @staticmethod
12165    def read_one(reader):
12166        # Do nothing if there aren't more tags:
12167        if not reader.forward():
12168            return None
12169
12170        # Create the object:
12171        obj = types.OpenstackVolumeAuthenticationKey()
12172
12173        # Process the attributes:
12174        obj.href = reader.get_attribute('href')
12175        value = reader.get_attribute('id')
12176        if value is not None:
12177            obj.id = value
12178
12179        # Discard the start tag:
12180        empty = reader.empty_element()
12181        reader.read()
12182        if empty:
12183            return obj
12184
12185        # Process the inner elements:
12186        links = []
12187        while reader.forward():
12188            tag = reader.node_name()
12189            if tag == 'comment':
12190                obj.comment = Reader.read_string(reader)
12191            elif tag == 'creation_date':
12192                obj.creation_date = Reader.read_date(reader)
12193            elif tag == 'description':
12194                obj.description = Reader.read_string(reader)
12195            elif tag == 'name':
12196                obj.name = Reader.read_string(reader)
12197            elif tag == 'openstack_volume_provider':
12198                obj.openstack_volume_provider = OpenStackVolumeProviderReader.read_one(reader)
12199            elif tag == 'usage_type':
12200                obj.usage_type = Reader.read_enum(types.OpenstackVolumeAuthenticationKeyUsageType, reader)
12201            elif tag == 'uuid':
12202                obj.uuid = Reader.read_string(reader)
12203            elif tag == 'value':
12204                obj.value = Reader.read_string(reader)
12205            else:
12206                reader.next_element()
12207        for link in links:
12208            OpenstackVolumeAuthenticationKeyReader._process_link(link, obj)
12209
12210        # Discard the end tag:
12211        reader.read()
12212
12213        return obj
12214
12215    @staticmethod
12216    def read_many(reader):
12217        # Do nothing if there aren't more tags:
12218        objs = List()
12219        if not reader.forward():
12220            return objs
12221
12222        # Process the attributes:
12223        objs.href = reader.get_attribute('href')
12224
12225        # Discard the start tag:
12226        empty = reader.empty_element()
12227        reader.read()
12228        if empty:
12229            return objs
12230
12231        # Process the inner elements:
12232        while reader.forward():
12233            objs.append(OpenstackVolumeAuthenticationKeyReader.read_one(reader))
12234
12235        # Discard the end tag:
12236        reader.read()
12237
12238        return objs
12239
12240
12241class OperatingSystemReader(Reader):
12242
12243    def __init__(self):
12244        super(OperatingSystemReader, self).__init__()
12245
12246    @staticmethod
12247    def read_one(reader):
12248        # Do nothing if there aren't more tags:
12249        if not reader.forward():
12250            return None
12251
12252        # Create the object:
12253        obj = types.OperatingSystem()
12254
12255        # Process the attributes:
12256        obj.href = reader.get_attribute('href')
12257
12258        # Discard the start tag:
12259        empty = reader.empty_element()
12260        reader.read()
12261        if empty:
12262            return obj
12263
12264        # Process the inner elements:
12265        links = []
12266        while reader.forward():
12267            tag = reader.node_name()
12268            if tag == 'boot':
12269                obj.boot = BootReader.read_one(reader)
12270            elif tag == 'cmdline':
12271                obj.cmdline = Reader.read_string(reader)
12272            elif tag == 'custom_kernel_cmdline':
12273                obj.custom_kernel_cmdline = Reader.read_string(reader)
12274            elif tag == 'initrd':
12275                obj.initrd = Reader.read_string(reader)
12276            elif tag == 'kernel':
12277                obj.kernel = Reader.read_string(reader)
12278            elif tag == 'reported_kernel_cmdline':
12279                obj.reported_kernel_cmdline = Reader.read_string(reader)
12280            elif tag == 'type':
12281                obj.type = Reader.read_string(reader)
12282            elif tag == 'version':
12283                obj.version = VersionReader.read_one(reader)
12284            else:
12285                reader.next_element()
12286        for link in links:
12287            OperatingSystemReader._process_link(link, obj)
12288
12289        # Discard the end tag:
12290        reader.read()
12291
12292        return obj
12293
12294    @staticmethod
12295    def read_many(reader):
12296        # Do nothing if there aren't more tags:
12297        objs = List()
12298        if not reader.forward():
12299            return objs
12300
12301        # Process the attributes:
12302        objs.href = reader.get_attribute('href')
12303
12304        # Discard the start tag:
12305        empty = reader.empty_element()
12306        reader.read()
12307        if empty:
12308            return objs
12309
12310        # Process the inner elements:
12311        while reader.forward():
12312            objs.append(OperatingSystemReader.read_one(reader))
12313
12314        # Discard the end tag:
12315        reader.read()
12316
12317        return objs
12318
12319
12320class OperatingSystemInfoReader(Reader):
12321
12322    def __init__(self):
12323        super(OperatingSystemInfoReader, self).__init__()
12324
12325    @staticmethod
12326    def read_one(reader):
12327        # Do nothing if there aren't more tags:
12328        if not reader.forward():
12329            return None
12330
12331        # Create the object:
12332        obj = types.OperatingSystemInfo()
12333
12334        # Process the attributes:
12335        obj.href = reader.get_attribute('href')
12336        value = reader.get_attribute('id')
12337        if value is not None:
12338            obj.id = value
12339
12340        # Discard the start tag:
12341        empty = reader.empty_element()
12342        reader.read()
12343        if empty:
12344            return obj
12345
12346        # Process the inner elements:
12347        links = []
12348        while reader.forward():
12349            tag = reader.node_name()
12350            if tag == 'architecture':
12351                obj.architecture = Reader.read_enum(types.Architecture, reader)
12352            elif tag == 'comment':
12353                obj.comment = Reader.read_string(reader)
12354            elif tag == 'description':
12355                obj.description = Reader.read_string(reader)
12356            elif tag == 'large_icon':
12357                obj.large_icon = IconReader.read_one(reader)
12358            elif tag == 'name':
12359                obj.name = Reader.read_string(reader)
12360            elif tag == 'small_icon':
12361                obj.small_icon = IconReader.read_one(reader)
12362            else:
12363                reader.next_element()
12364        for link in links:
12365            OperatingSystemInfoReader._process_link(link, obj)
12366
12367        # Discard the end tag:
12368        reader.read()
12369
12370        return obj
12371
12372    @staticmethod
12373    def read_many(reader):
12374        # Do nothing if there aren't more tags:
12375        objs = List()
12376        if not reader.forward():
12377            return objs
12378
12379        # Process the attributes:
12380        objs.href = reader.get_attribute('href')
12381
12382        # Discard the start tag:
12383        empty = reader.empty_element()
12384        reader.read()
12385        if empty:
12386            return objs
12387
12388        # Process the inner elements:
12389        while reader.forward():
12390            objs.append(OperatingSystemInfoReader.read_one(reader))
12391
12392        # Discard the end tag:
12393        reader.read()
12394
12395        return objs
12396
12397
12398class OptionReader(Reader):
12399
12400    def __init__(self):
12401        super(OptionReader, self).__init__()
12402
12403    @staticmethod
12404    def read_one(reader):
12405        # Do nothing if there aren't more tags:
12406        if not reader.forward():
12407            return None
12408
12409        # Create the object:
12410        obj = types.Option()
12411
12412        # Process the attributes:
12413        obj.href = reader.get_attribute('href')
12414
12415        # Discard the start tag:
12416        empty = reader.empty_element()
12417        reader.read()
12418        if empty:
12419            return obj
12420
12421        # Process the inner elements:
12422        links = []
12423        while reader.forward():
12424            tag = reader.node_name()
12425            if tag == 'name':
12426                obj.name = Reader.read_string(reader)
12427            elif tag == 'type':
12428                obj.type = Reader.read_string(reader)
12429            elif tag == 'value':
12430                obj.value = Reader.read_string(reader)
12431            else:
12432                reader.next_element()
12433        for link in links:
12434            OptionReader._process_link(link, obj)
12435
12436        # Discard the end tag:
12437        reader.read()
12438
12439        return obj
12440
12441    @staticmethod
12442    def read_many(reader):
12443        # Do nothing if there aren't more tags:
12444        objs = List()
12445        if not reader.forward():
12446            return objs
12447
12448        # Process the attributes:
12449        objs.href = reader.get_attribute('href')
12450
12451        # Discard the start tag:
12452        empty = reader.empty_element()
12453        reader.read()
12454        if empty:
12455            return objs
12456
12457        # Process the inner elements:
12458        while reader.forward():
12459            objs.append(OptionReader.read_one(reader))
12460
12461        # Discard the end tag:
12462        reader.read()
12463
12464        return objs
12465
12466
12467class PackageReader(Reader):
12468
12469    def __init__(self):
12470        super(PackageReader, self).__init__()
12471
12472    @staticmethod
12473    def read_one(reader):
12474        # Do nothing if there aren't more tags:
12475        if not reader.forward():
12476            return None
12477
12478        # Create the object:
12479        obj = types.Package()
12480
12481        # Process the attributes:
12482        obj.href = reader.get_attribute('href')
12483
12484        # Discard the start tag:
12485        empty = reader.empty_element()
12486        reader.read()
12487        if empty:
12488            return obj
12489
12490        # Process the inner elements:
12491        links = []
12492        while reader.forward():
12493            tag = reader.node_name()
12494            if tag == 'name':
12495                obj.name = Reader.read_string(reader)
12496            else:
12497                reader.next_element()
12498        for link in links:
12499            PackageReader._process_link(link, obj)
12500
12501        # Discard the end tag:
12502        reader.read()
12503
12504        return obj
12505
12506    @staticmethod
12507    def read_many(reader):
12508        # Do nothing if there aren't more tags:
12509        objs = List()
12510        if not reader.forward():
12511            return objs
12512
12513        # Process the attributes:
12514        objs.href = reader.get_attribute('href')
12515
12516        # Discard the start tag:
12517        empty = reader.empty_element()
12518        reader.read()
12519        if empty:
12520            return objs
12521
12522        # Process the inner elements:
12523        while reader.forward():
12524            objs.append(PackageReader.read_one(reader))
12525
12526        # Discard the end tag:
12527        reader.read()
12528
12529        return objs
12530
12531
12532class PayloadReader(Reader):
12533
12534    def __init__(self):
12535        super(PayloadReader, self).__init__()
12536
12537    @staticmethod
12538    def read_one(reader):
12539        # Do nothing if there aren't more tags:
12540        if not reader.forward():
12541            return None
12542
12543        # Create the object:
12544        obj = types.Payload()
12545
12546        # Process the attributes:
12547        obj.href = reader.get_attribute('href')
12548
12549        # Discard the start tag:
12550        empty = reader.empty_element()
12551        reader.read()
12552        if empty:
12553            return obj
12554
12555        # Process the inner elements:
12556        links = []
12557        while reader.forward():
12558            tag = reader.node_name()
12559            if tag == 'files':
12560                obj.files = FileReader.read_many(reader)
12561            elif tag == 'type':
12562                obj.type = Reader.read_enum(types.VmDeviceType, reader)
12563            elif tag == 'volume_id':
12564                obj.volume_id = Reader.read_string(reader)
12565            else:
12566                reader.next_element()
12567        for link in links:
12568            PayloadReader._process_link(link, obj)
12569
12570        # Discard the end tag:
12571        reader.read()
12572
12573        return obj
12574
12575    @staticmethod
12576    def read_many(reader):
12577        # Do nothing if there aren't more tags:
12578        objs = List()
12579        if not reader.forward():
12580            return objs
12581
12582        # Process the attributes:
12583        objs.href = reader.get_attribute('href')
12584
12585        # Discard the start tag:
12586        empty = reader.empty_element()
12587        reader.read()
12588        if empty:
12589            return objs
12590
12591        # Process the inner elements:
12592        while reader.forward():
12593            objs.append(PayloadReader.read_one(reader))
12594
12595        # Discard the end tag:
12596        reader.read()
12597
12598        return objs
12599
12600
12601class PermissionReader(Reader):
12602
12603    def __init__(self):
12604        super(PermissionReader, self).__init__()
12605
12606    @staticmethod
12607    def read_one(reader):
12608        # Do nothing if there aren't more tags:
12609        if not reader.forward():
12610            return None
12611
12612        # Create the object:
12613        obj = types.Permission()
12614
12615        # Process the attributes:
12616        obj.href = reader.get_attribute('href')
12617        value = reader.get_attribute('id')
12618        if value is not None:
12619            obj.id = value
12620
12621        # Discard the start tag:
12622        empty = reader.empty_element()
12623        reader.read()
12624        if empty:
12625            return obj
12626
12627        # Process the inner elements:
12628        links = []
12629        while reader.forward():
12630            tag = reader.node_name()
12631            if tag == 'cluster':
12632                obj.cluster = ClusterReader.read_one(reader)
12633            elif tag == 'comment':
12634                obj.comment = Reader.read_string(reader)
12635            elif tag == 'data_center':
12636                obj.data_center = DataCenterReader.read_one(reader)
12637            elif tag == 'description':
12638                obj.description = Reader.read_string(reader)
12639            elif tag == 'disk':
12640                obj.disk = DiskReader.read_one(reader)
12641            elif tag == 'group':
12642                obj.group = GroupReader.read_one(reader)
12643            elif tag == 'host':
12644                obj.host = HostReader.read_one(reader)
12645            elif tag == 'name':
12646                obj.name = Reader.read_string(reader)
12647            elif tag == 'role':
12648                obj.role = RoleReader.read_one(reader)
12649            elif tag == 'storage_domain':
12650                obj.storage_domain = StorageDomainReader.read_one(reader)
12651            elif tag == 'template':
12652                obj.template = TemplateReader.read_one(reader)
12653            elif tag == 'user':
12654                obj.user = UserReader.read_one(reader)
12655            elif tag == 'vm':
12656                obj.vm = VmReader.read_one(reader)
12657            elif tag == 'vm_pool':
12658                obj.vm_pool = VmPoolReader.read_one(reader)
12659            else:
12660                reader.next_element()
12661        for link in links:
12662            PermissionReader._process_link(link, obj)
12663
12664        # Discard the end tag:
12665        reader.read()
12666
12667        return obj
12668
12669    @staticmethod
12670    def read_many(reader):
12671        # Do nothing if there aren't more tags:
12672        objs = List()
12673        if not reader.forward():
12674            return objs
12675
12676        # Process the attributes:
12677        objs.href = reader.get_attribute('href')
12678
12679        # Discard the start tag:
12680        empty = reader.empty_element()
12681        reader.read()
12682        if empty:
12683            return objs
12684
12685        # Process the inner elements:
12686        while reader.forward():
12687            objs.append(PermissionReader.read_one(reader))
12688
12689        # Discard the end tag:
12690        reader.read()
12691
12692        return objs
12693
12694
12695class PermitReader(Reader):
12696
12697    def __init__(self):
12698        super(PermitReader, self).__init__()
12699
12700    @staticmethod
12701    def read_one(reader):
12702        # Do nothing if there aren't more tags:
12703        if not reader.forward():
12704            return None
12705
12706        # Create the object:
12707        obj = types.Permit()
12708
12709        # Process the attributes:
12710        obj.href = reader.get_attribute('href')
12711        value = reader.get_attribute('id')
12712        if value is not None:
12713            obj.id = value
12714
12715        # Discard the start tag:
12716        empty = reader.empty_element()
12717        reader.read()
12718        if empty:
12719            return obj
12720
12721        # Process the inner elements:
12722        links = []
12723        while reader.forward():
12724            tag = reader.node_name()
12725            if tag == 'administrative':
12726                obj.administrative = Reader.read_boolean(reader)
12727            elif tag == 'comment':
12728                obj.comment = Reader.read_string(reader)
12729            elif tag == 'description':
12730                obj.description = Reader.read_string(reader)
12731            elif tag == 'name':
12732                obj.name = Reader.read_string(reader)
12733            elif tag == 'role':
12734                obj.role = RoleReader.read_one(reader)
12735            else:
12736                reader.next_element()
12737        for link in links:
12738            PermitReader._process_link(link, obj)
12739
12740        # Discard the end tag:
12741        reader.read()
12742
12743        return obj
12744
12745    @staticmethod
12746    def read_many(reader):
12747        # Do nothing if there aren't more tags:
12748        objs = List()
12749        if not reader.forward():
12750            return objs
12751
12752        # Process the attributes:
12753        objs.href = reader.get_attribute('href')
12754
12755        # Discard the start tag:
12756        empty = reader.empty_element()
12757        reader.read()
12758        if empty:
12759            return objs
12760
12761        # Process the inner elements:
12762        while reader.forward():
12763            objs.append(PermitReader.read_one(reader))
12764
12765        # Discard the end tag:
12766        reader.read()
12767
12768        return objs
12769
12770
12771class PmProxyReader(Reader):
12772
12773    def __init__(self):
12774        super(PmProxyReader, self).__init__()
12775
12776    @staticmethod
12777    def read_one(reader):
12778        # Do nothing if there aren't more tags:
12779        if not reader.forward():
12780            return None
12781
12782        # Create the object:
12783        obj = types.PmProxy()
12784
12785        # Process the attributes:
12786        obj.href = reader.get_attribute('href')
12787
12788        # Discard the start tag:
12789        empty = reader.empty_element()
12790        reader.read()
12791        if empty:
12792            return obj
12793
12794        # Process the inner elements:
12795        links = []
12796        while reader.forward():
12797            tag = reader.node_name()
12798            if tag == 'type':
12799                obj.type = Reader.read_enum(types.PmProxyType, reader)
12800            else:
12801                reader.next_element()
12802        for link in links:
12803            PmProxyReader._process_link(link, obj)
12804
12805        # Discard the end tag:
12806        reader.read()
12807
12808        return obj
12809
12810    @staticmethod
12811    def read_many(reader):
12812        # Do nothing if there aren't more tags:
12813        objs = List()
12814        if not reader.forward():
12815            return objs
12816
12817        # Process the attributes:
12818        objs.href = reader.get_attribute('href')
12819
12820        # Discard the start tag:
12821        empty = reader.empty_element()
12822        reader.read()
12823        if empty:
12824            return objs
12825
12826        # Process the inner elements:
12827        while reader.forward():
12828            objs.append(PmProxyReader.read_one(reader))
12829
12830        # Discard the end tag:
12831        reader.read()
12832
12833        return objs
12834
12835
12836class PortMirroringReader(Reader):
12837
12838    def __init__(self):
12839        super(PortMirroringReader, self).__init__()
12840
12841    @staticmethod
12842    def read_one(reader):
12843        # Do nothing if there aren't more tags:
12844        if not reader.forward():
12845            return None
12846
12847        # Create the object:
12848        obj = types.PortMirroring()
12849
12850        # Process the attributes:
12851        obj.href = reader.get_attribute('href')
12852
12853        # Discard the start tag:
12854        empty = reader.empty_element()
12855        reader.read()
12856        if empty:
12857            return obj
12858
12859        # Process the inner elements:
12860        reader.next_element()
12861
12862        # Discard the end tag:
12863        reader.read()
12864
12865        return obj
12866
12867    @staticmethod
12868    def read_many(reader):
12869        # Do nothing if there aren't more tags:
12870        objs = List()
12871        if not reader.forward():
12872            return objs
12873
12874        # Process the attributes:
12875        objs.href = reader.get_attribute('href')
12876
12877        # Discard the start tag:
12878        empty = reader.empty_element()
12879        reader.read()
12880        if empty:
12881            return objs
12882
12883        # Process the inner elements:
12884        while reader.forward():
12885            objs.append(PortMirroringReader.read_one(reader))
12886
12887        # Discard the end tag:
12888        reader.read()
12889
12890        return objs
12891
12892
12893class PowerManagementReader(Reader):
12894
12895    def __init__(self):
12896        super(PowerManagementReader, self).__init__()
12897
12898    @staticmethod
12899    def read_one(reader):
12900        # Do nothing if there aren't more tags:
12901        if not reader.forward():
12902            return None
12903
12904        # Create the object:
12905        obj = types.PowerManagement()
12906
12907        # Process the attributes:
12908        obj.href = reader.get_attribute('href')
12909
12910        # Discard the start tag:
12911        empty = reader.empty_element()
12912        reader.read()
12913        if empty:
12914            return obj
12915
12916        # Process the inner elements:
12917        links = []
12918        while reader.forward():
12919            tag = reader.node_name()
12920            if tag == 'address':
12921                obj.address = Reader.read_string(reader)
12922            elif tag == 'agents':
12923                obj.agents = AgentReader.read_many(reader)
12924            elif tag == 'automatic_pm_enabled':
12925                obj.automatic_pm_enabled = Reader.read_boolean(reader)
12926            elif tag == 'enabled':
12927                obj.enabled = Reader.read_boolean(reader)
12928            elif tag == 'kdump_detection':
12929                obj.kdump_detection = Reader.read_boolean(reader)
12930            elif tag == 'options':
12931                obj.options = OptionReader.read_many(reader)
12932            elif tag == 'password':
12933                obj.password = Reader.read_string(reader)
12934            elif tag == 'pm_proxies':
12935                obj.pm_proxies = PmProxyReader.read_many(reader)
12936            elif tag == 'status':
12937                obj.status = Reader.read_enum(types.PowerManagementStatus, reader)
12938            elif tag == 'type':
12939                obj.type = Reader.read_string(reader)
12940            elif tag == 'username':
12941                obj.username = Reader.read_string(reader)
12942            else:
12943                reader.next_element()
12944        for link in links:
12945            PowerManagementReader._process_link(link, obj)
12946
12947        # Discard the end tag:
12948        reader.read()
12949
12950        return obj
12951
12952    @staticmethod
12953    def read_many(reader):
12954        # Do nothing if there aren't more tags:
12955        objs = List()
12956        if not reader.forward():
12957            return objs
12958
12959        # Process the attributes:
12960        objs.href = reader.get_attribute('href')
12961
12962        # Discard the start tag:
12963        empty = reader.empty_element()
12964        reader.read()
12965        if empty:
12966            return objs
12967
12968        # Process the inner elements:
12969        while reader.forward():
12970            objs.append(PowerManagementReader.read_one(reader))
12971
12972        # Discard the end tag:
12973        reader.read()
12974
12975        return objs
12976
12977
12978class ProductReader(Reader):
12979
12980    def __init__(self):
12981        super(ProductReader, self).__init__()
12982
12983    @staticmethod
12984    def read_one(reader):
12985        # Do nothing if there aren't more tags:
12986        if not reader.forward():
12987            return None
12988
12989        # Create the object:
12990        obj = types.Product()
12991
12992        # Process the attributes:
12993        obj.href = reader.get_attribute('href')
12994        value = reader.get_attribute('id')
12995        if value is not None:
12996            obj.id = value
12997
12998        # Discard the start tag:
12999        empty = reader.empty_element()
13000        reader.read()
13001        if empty:
13002            return obj
13003
13004        # Process the inner elements:
13005        links = []
13006        while reader.forward():
13007            tag = reader.node_name()
13008            if tag == 'comment':
13009                obj.comment = Reader.read_string(reader)
13010            elif tag == 'description':
13011                obj.description = Reader.read_string(reader)
13012            elif tag == 'name':
13013                obj.name = Reader.read_string(reader)
13014            else:
13015                reader.next_element()
13016        for link in links:
13017            ProductReader._process_link(link, obj)
13018
13019        # Discard the end tag:
13020        reader.read()
13021
13022        return obj
13023
13024    @staticmethod
13025    def read_many(reader):
13026        # Do nothing if there aren't more tags:
13027        objs = List()
13028        if not reader.forward():
13029            return objs
13030
13031        # Process the attributes:
13032        objs.href = reader.get_attribute('href')
13033
13034        # Discard the start tag:
13035        empty = reader.empty_element()
13036        reader.read()
13037        if empty:
13038            return objs
13039
13040        # Process the inner elements:
13041        while reader.forward():
13042            objs.append(ProductReader.read_one(reader))
13043
13044        # Discard the end tag:
13045        reader.read()
13046
13047        return objs
13048
13049
13050class ProductInfoReader(Reader):
13051
13052    def __init__(self):
13053        super(ProductInfoReader, self).__init__()
13054
13055    @staticmethod
13056    def read_one(reader):
13057        # Do nothing if there aren't more tags:
13058        if not reader.forward():
13059            return None
13060
13061        # Create the object:
13062        obj = types.ProductInfo()
13063
13064        # Process the attributes:
13065        obj.href = reader.get_attribute('href')
13066
13067        # Discard the start tag:
13068        empty = reader.empty_element()
13069        reader.read()
13070        if empty:
13071            return obj
13072
13073        # Process the inner elements:
13074        links = []
13075        while reader.forward():
13076            tag = reader.node_name()
13077            if tag == 'instance_id':
13078                obj.instance_id = Reader.read_string(reader)
13079            elif tag == 'name':
13080                obj.name = Reader.read_string(reader)
13081            elif tag == 'vendor':
13082                obj.vendor = Reader.read_string(reader)
13083            elif tag == 'version':
13084                obj.version = VersionReader.read_one(reader)
13085            else:
13086                reader.next_element()
13087        for link in links:
13088            ProductInfoReader._process_link(link, obj)
13089
13090        # Discard the end tag:
13091        reader.read()
13092
13093        return obj
13094
13095    @staticmethod
13096    def read_many(reader):
13097        # Do nothing if there aren't more tags:
13098        objs = List()
13099        if not reader.forward():
13100            return objs
13101
13102        # Process the attributes:
13103        objs.href = reader.get_attribute('href')
13104
13105        # Discard the start tag:
13106        empty = reader.empty_element()
13107        reader.read()
13108        if empty:
13109            return objs
13110
13111        # Process the inner elements:
13112        while reader.forward():
13113            objs.append(ProductInfoReader.read_one(reader))
13114
13115        # Discard the end tag:
13116        reader.read()
13117
13118        return objs
13119
13120
13121class ProfileDetailReader(Reader):
13122
13123    def __init__(self):
13124        super(ProfileDetailReader, self).__init__()
13125
13126    @staticmethod
13127    def read_one(reader):
13128        # Do nothing if there aren't more tags:
13129        if not reader.forward():
13130            return None
13131
13132        # Create the object:
13133        obj = types.ProfileDetail()
13134
13135        # Process the attributes:
13136        obj.href = reader.get_attribute('href')
13137
13138        # Discard the start tag:
13139        empty = reader.empty_element()
13140        reader.read()
13141        if empty:
13142            return obj
13143
13144        # Process the inner elements:
13145        links = []
13146        while reader.forward():
13147            tag = reader.node_name()
13148            if tag == 'block_statistics':
13149                obj.block_statistics = BlockStatisticReader.read_many(reader)
13150            elif tag == 'duration':
13151                obj.duration = Reader.read_integer(reader)
13152            elif tag == 'fop_statistics':
13153                obj.fop_statistics = FopStatisticReader.read_many(reader)
13154            elif tag == 'profile_type':
13155                obj.profile_type = Reader.read_string(reader)
13156            elif tag == 'statistics':
13157                obj.statistics = StatisticReader.read_many(reader)
13158            else:
13159                reader.next_element()
13160        for link in links:
13161            ProfileDetailReader._process_link(link, obj)
13162
13163        # Discard the end tag:
13164        reader.read()
13165
13166        return obj
13167
13168    @staticmethod
13169    def read_many(reader):
13170        # Do nothing if there aren't more tags:
13171        objs = List()
13172        if not reader.forward():
13173            return objs
13174
13175        # Process the attributes:
13176        objs.href = reader.get_attribute('href')
13177
13178        # Discard the start tag:
13179        empty = reader.empty_element()
13180        reader.read()
13181        if empty:
13182            return objs
13183
13184        # Process the inner elements:
13185        while reader.forward():
13186            objs.append(ProfileDetailReader.read_one(reader))
13187
13188        # Discard the end tag:
13189        reader.read()
13190
13191        return objs
13192
13193
13194class PropertyReader(Reader):
13195
13196    def __init__(self):
13197        super(PropertyReader, self).__init__()
13198
13199    @staticmethod
13200    def read_one(reader):
13201        # Do nothing if there aren't more tags:
13202        if not reader.forward():
13203            return None
13204
13205        # Create the object:
13206        obj = types.Property()
13207
13208        # Process the attributes:
13209        obj.href = reader.get_attribute('href')
13210
13211        # Discard the start tag:
13212        empty = reader.empty_element()
13213        reader.read()
13214        if empty:
13215            return obj
13216
13217        # Process the inner elements:
13218        links = []
13219        while reader.forward():
13220            tag = reader.node_name()
13221            if tag == 'name':
13222                obj.name = Reader.read_string(reader)
13223            elif tag == 'value':
13224                obj.value = Reader.read_string(reader)
13225            else:
13226                reader.next_element()
13227        for link in links:
13228            PropertyReader._process_link(link, obj)
13229
13230        # Discard the end tag:
13231        reader.read()
13232
13233        return obj
13234
13235    @staticmethod
13236    def read_many(reader):
13237        # Do nothing if there aren't more tags:
13238        objs = List()
13239        if not reader.forward():
13240            return objs
13241
13242        # Process the attributes:
13243        objs.href = reader.get_attribute('href')
13244
13245        # Discard the start tag:
13246        empty = reader.empty_element()
13247        reader.read()
13248        if empty:
13249            return objs
13250
13251        # Process the inner elements:
13252        while reader.forward():
13253            objs.append(PropertyReader.read_one(reader))
13254
13255        # Discard the end tag:
13256        reader.read()
13257
13258        return objs
13259
13260
13261class ProxyTicketReader(Reader):
13262
13263    def __init__(self):
13264        super(ProxyTicketReader, self).__init__()
13265
13266    @staticmethod
13267    def read_one(reader):
13268        # Do nothing if there aren't more tags:
13269        if not reader.forward():
13270            return None
13271
13272        # Create the object:
13273        obj = types.ProxyTicket()
13274
13275        # Process the attributes:
13276        obj.href = reader.get_attribute('href')
13277
13278        # Discard the start tag:
13279        empty = reader.empty_element()
13280        reader.read()
13281        if empty:
13282            return obj
13283
13284        # Process the inner elements:
13285        links = []
13286        while reader.forward():
13287            tag = reader.node_name()
13288            if tag == 'value':
13289                obj.value = Reader.read_string(reader)
13290            else:
13291                reader.next_element()
13292        for link in links:
13293            ProxyTicketReader._process_link(link, obj)
13294
13295        # Discard the end tag:
13296        reader.read()
13297
13298        return obj
13299
13300    @staticmethod
13301    def read_many(reader):
13302        # Do nothing if there aren't more tags:
13303        objs = List()
13304        if not reader.forward():
13305            return objs
13306
13307        # Process the attributes:
13308        objs.href = reader.get_attribute('href')
13309
13310        # Discard the start tag:
13311        empty = reader.empty_element()
13312        reader.read()
13313        if empty:
13314            return objs
13315
13316        # Process the inner elements:
13317        while reader.forward():
13318            objs.append(ProxyTicketReader.read_one(reader))
13319
13320        # Discard the end tag:
13321        reader.read()
13322
13323        return objs
13324
13325
13326class QosReader(Reader):
13327
13328    def __init__(self):
13329        super(QosReader, self).__init__()
13330
13331    @staticmethod
13332    def read_one(reader):
13333        # Do nothing if there aren't more tags:
13334        if not reader.forward():
13335            return None
13336
13337        # Create the object:
13338        obj = types.Qos()
13339
13340        # Process the attributes:
13341        obj.href = reader.get_attribute('href')
13342        value = reader.get_attribute('id')
13343        if value is not None:
13344            obj.id = value
13345
13346        # Discard the start tag:
13347        empty = reader.empty_element()
13348        reader.read()
13349        if empty:
13350            return obj
13351
13352        # Process the inner elements:
13353        links = []
13354        while reader.forward():
13355            tag = reader.node_name()
13356            if tag == 'comment':
13357                obj.comment = Reader.read_string(reader)
13358            elif tag == 'cpu_limit':
13359                obj.cpu_limit = Reader.read_integer(reader)
13360            elif tag == 'data_center':
13361                obj.data_center = DataCenterReader.read_one(reader)
13362            elif tag == 'description':
13363                obj.description = Reader.read_string(reader)
13364            elif tag == 'inbound_average':
13365                obj.inbound_average = Reader.read_integer(reader)
13366            elif tag == 'inbound_burst':
13367                obj.inbound_burst = Reader.read_integer(reader)
13368            elif tag == 'inbound_peak':
13369                obj.inbound_peak = Reader.read_integer(reader)
13370            elif tag == 'max_iops':
13371                obj.max_iops = Reader.read_integer(reader)
13372            elif tag == 'max_read_iops':
13373                obj.max_read_iops = Reader.read_integer(reader)
13374            elif tag == 'max_read_throughput':
13375                obj.max_read_throughput = Reader.read_integer(reader)
13376            elif tag == 'max_throughput':
13377                obj.max_throughput = Reader.read_integer(reader)
13378            elif tag == 'max_write_iops':
13379                obj.max_write_iops = Reader.read_integer(reader)
13380            elif tag == 'max_write_throughput':
13381                obj.max_write_throughput = Reader.read_integer(reader)
13382            elif tag == 'name':
13383                obj.name = Reader.read_string(reader)
13384            elif tag == 'outbound_average':
13385                obj.outbound_average = Reader.read_integer(reader)
13386            elif tag == 'outbound_average_linkshare':
13387                obj.outbound_average_linkshare = Reader.read_integer(reader)
13388            elif tag == 'outbound_average_realtime':
13389                obj.outbound_average_realtime = Reader.read_integer(reader)
13390            elif tag == 'outbound_average_upperlimit':
13391                obj.outbound_average_upperlimit = Reader.read_integer(reader)
13392            elif tag == 'outbound_burst':
13393                obj.outbound_burst = Reader.read_integer(reader)
13394            elif tag == 'outbound_peak':
13395                obj.outbound_peak = Reader.read_integer(reader)
13396            elif tag == 'type':
13397                obj.type = Reader.read_enum(types.QosType, reader)
13398            else:
13399                reader.next_element()
13400        for link in links:
13401            QosReader._process_link(link, obj)
13402
13403        # Discard the end tag:
13404        reader.read()
13405
13406        return obj
13407
13408    @staticmethod
13409    def read_many(reader):
13410        # Do nothing if there aren't more tags:
13411        objs = List()
13412        if not reader.forward():
13413            return objs
13414
13415        # Process the attributes:
13416        objs.href = reader.get_attribute('href')
13417
13418        # Discard the start tag:
13419        empty = reader.empty_element()
13420        reader.read()
13421        if empty:
13422            return objs
13423
13424        # Process the inner elements:
13425        while reader.forward():
13426            objs.append(QosReader.read_one(reader))
13427
13428        # Discard the end tag:
13429        reader.read()
13430
13431        return objs
13432
13433
13434class QuotaReader(Reader):
13435
13436    def __init__(self):
13437        super(QuotaReader, self).__init__()
13438
13439    @staticmethod
13440    def read_one(reader):
13441        # Do nothing if there aren't more tags:
13442        if not reader.forward():
13443            return None
13444
13445        # Create the object:
13446        obj = types.Quota()
13447
13448        # Process the attributes:
13449        obj.href = reader.get_attribute('href')
13450        value = reader.get_attribute('id')
13451        if value is not None:
13452            obj.id = value
13453
13454        # Discard the start tag:
13455        empty = reader.empty_element()
13456        reader.read()
13457        if empty:
13458            return obj
13459
13460        # Process the inner elements:
13461        links = []
13462        while reader.forward():
13463            tag = reader.node_name()
13464            if tag == 'cluster_hard_limit_pct':
13465                obj.cluster_hard_limit_pct = Reader.read_integer(reader)
13466            elif tag == 'cluster_soft_limit_pct':
13467                obj.cluster_soft_limit_pct = Reader.read_integer(reader)
13468            elif tag == 'comment':
13469                obj.comment = Reader.read_string(reader)
13470            elif tag == 'data_center':
13471                obj.data_center = DataCenterReader.read_one(reader)
13472            elif tag == 'description':
13473                obj.description = Reader.read_string(reader)
13474            elif tag == 'disks':
13475                obj.disks = DiskReader.read_many(reader)
13476            elif tag == 'name':
13477                obj.name = Reader.read_string(reader)
13478            elif tag == 'permissions':
13479                obj.permissions = PermissionReader.read_many(reader)
13480            elif tag == 'quota_cluster_limits':
13481                obj.quota_cluster_limits = QuotaClusterLimitReader.read_many(reader)
13482            elif tag == 'quota_storage_limits':
13483                obj.quota_storage_limits = QuotaStorageLimitReader.read_many(reader)
13484            elif tag == 'storage_hard_limit_pct':
13485                obj.storage_hard_limit_pct = Reader.read_integer(reader)
13486            elif tag == 'storage_soft_limit_pct':
13487                obj.storage_soft_limit_pct = Reader.read_integer(reader)
13488            elif tag == 'users':
13489                obj.users = UserReader.read_many(reader)
13490            elif tag == 'vms':
13491                obj.vms = VmReader.read_many(reader)
13492            elif tag == 'link':
13493                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
13494                reader.next_element()
13495            else:
13496                reader.next_element()
13497        for link in links:
13498            QuotaReader._process_link(link, obj)
13499
13500        # Discard the end tag:
13501        reader.read()
13502
13503        return obj
13504
13505    @staticmethod
13506    def read_many(reader):
13507        # Do nothing if there aren't more tags:
13508        objs = List()
13509        if not reader.forward():
13510            return objs
13511
13512        # Process the attributes:
13513        objs.href = reader.get_attribute('href')
13514
13515        # Discard the start tag:
13516        empty = reader.empty_element()
13517        reader.read()
13518        if empty:
13519            return objs
13520
13521        # Process the inner elements:
13522        while reader.forward():
13523            objs.append(QuotaReader.read_one(reader))
13524
13525        # Discard the end tag:
13526        reader.read()
13527
13528        return objs
13529
13530    @staticmethod
13531    def _process_link(link, obj):
13532        # Process the attributes:
13533        rel = link[0]
13534        href = link[1]
13535        if href and rel:
13536            if rel == "permissions":
13537                if obj.permissions is not None:
13538                    obj.permissions.href = href
13539                else:
13540                    obj.permissions = List(href)
13541            elif rel == "quotaclusterlimits":
13542                if obj.quota_cluster_limits is not None:
13543                    obj.quota_cluster_limits.href = href
13544                else:
13545                    obj.quota_cluster_limits = List(href)
13546            elif rel == "quotastoragelimits":
13547                if obj.quota_storage_limits is not None:
13548                    obj.quota_storage_limits.href = href
13549                else:
13550                    obj.quota_storage_limits = List(href)
13551
13552
13553class QuotaClusterLimitReader(Reader):
13554
13555    def __init__(self):
13556        super(QuotaClusterLimitReader, self).__init__()
13557
13558    @staticmethod
13559    def read_one(reader):
13560        # Do nothing if there aren't more tags:
13561        if not reader.forward():
13562            return None
13563
13564        # Create the object:
13565        obj = types.QuotaClusterLimit()
13566
13567        # Process the attributes:
13568        obj.href = reader.get_attribute('href')
13569        value = reader.get_attribute('id')
13570        if value is not None:
13571            obj.id = value
13572
13573        # Discard the start tag:
13574        empty = reader.empty_element()
13575        reader.read()
13576        if empty:
13577            return obj
13578
13579        # Process the inner elements:
13580        links = []
13581        while reader.forward():
13582            tag = reader.node_name()
13583            if tag == 'cluster':
13584                obj.cluster = ClusterReader.read_one(reader)
13585            elif tag == 'comment':
13586                obj.comment = Reader.read_string(reader)
13587            elif tag == 'description':
13588                obj.description = Reader.read_string(reader)
13589            elif tag == 'memory_limit':
13590                obj.memory_limit = Reader.read_decimal(reader)
13591            elif tag == 'memory_usage':
13592                obj.memory_usage = Reader.read_decimal(reader)
13593            elif tag == 'name':
13594                obj.name = Reader.read_string(reader)
13595            elif tag == 'quota':
13596                obj.quota = QuotaReader.read_one(reader)
13597            elif tag == 'vcpu_limit':
13598                obj.vcpu_limit = Reader.read_integer(reader)
13599            elif tag == 'vcpu_usage':
13600                obj.vcpu_usage = Reader.read_integer(reader)
13601            else:
13602                reader.next_element()
13603        for link in links:
13604            QuotaClusterLimitReader._process_link(link, obj)
13605
13606        # Discard the end tag:
13607        reader.read()
13608
13609        return obj
13610
13611    @staticmethod
13612    def read_many(reader):
13613        # Do nothing if there aren't more tags:
13614        objs = List()
13615        if not reader.forward():
13616            return objs
13617
13618        # Process the attributes:
13619        objs.href = reader.get_attribute('href')
13620
13621        # Discard the start tag:
13622        empty = reader.empty_element()
13623        reader.read()
13624        if empty:
13625            return objs
13626
13627        # Process the inner elements:
13628        while reader.forward():
13629            objs.append(QuotaClusterLimitReader.read_one(reader))
13630
13631        # Discard the end tag:
13632        reader.read()
13633
13634        return objs
13635
13636
13637class QuotaStorageLimitReader(Reader):
13638
13639    def __init__(self):
13640        super(QuotaStorageLimitReader, self).__init__()
13641
13642    @staticmethod
13643    def read_one(reader):
13644        # Do nothing if there aren't more tags:
13645        if not reader.forward():
13646            return None
13647
13648        # Create the object:
13649        obj = types.QuotaStorageLimit()
13650
13651        # Process the attributes:
13652        obj.href = reader.get_attribute('href')
13653        value = reader.get_attribute('id')
13654        if value is not None:
13655            obj.id = value
13656
13657        # Discard the start tag:
13658        empty = reader.empty_element()
13659        reader.read()
13660        if empty:
13661            return obj
13662
13663        # Process the inner elements:
13664        links = []
13665        while reader.forward():
13666            tag = reader.node_name()
13667            if tag == 'comment':
13668                obj.comment = Reader.read_string(reader)
13669            elif tag == 'description':
13670                obj.description = Reader.read_string(reader)
13671            elif tag == 'limit':
13672                obj.limit = Reader.read_integer(reader)
13673            elif tag == 'name':
13674                obj.name = Reader.read_string(reader)
13675            elif tag == 'quota':
13676                obj.quota = QuotaReader.read_one(reader)
13677            elif tag == 'storage_domain':
13678                obj.storage_domain = StorageDomainReader.read_one(reader)
13679            elif tag == 'usage':
13680                obj.usage = Reader.read_decimal(reader)
13681            else:
13682                reader.next_element()
13683        for link in links:
13684            QuotaStorageLimitReader._process_link(link, obj)
13685
13686        # Discard the end tag:
13687        reader.read()
13688
13689        return obj
13690
13691    @staticmethod
13692    def read_many(reader):
13693        # Do nothing if there aren't more tags:
13694        objs = List()
13695        if not reader.forward():
13696            return objs
13697
13698        # Process the attributes:
13699        objs.href = reader.get_attribute('href')
13700
13701        # Discard the start tag:
13702        empty = reader.empty_element()
13703        reader.read()
13704        if empty:
13705            return objs
13706
13707        # Process the inner elements:
13708        while reader.forward():
13709            objs.append(QuotaStorageLimitReader.read_one(reader))
13710
13711        # Discard the end tag:
13712        reader.read()
13713
13714        return objs
13715
13716
13717class RangeReader(Reader):
13718
13719    def __init__(self):
13720        super(RangeReader, self).__init__()
13721
13722    @staticmethod
13723    def read_one(reader):
13724        # Do nothing if there aren't more tags:
13725        if not reader.forward():
13726            return None
13727
13728        # Create the object:
13729        obj = types.Range()
13730
13731        # Process the attributes:
13732        obj.href = reader.get_attribute('href')
13733
13734        # Discard the start tag:
13735        empty = reader.empty_element()
13736        reader.read()
13737        if empty:
13738            return obj
13739
13740        # Process the inner elements:
13741        links = []
13742        while reader.forward():
13743            tag = reader.node_name()
13744            if tag == 'from':
13745                obj.from_ = Reader.read_string(reader)
13746            elif tag == 'to':
13747                obj.to = Reader.read_string(reader)
13748            else:
13749                reader.next_element()
13750        for link in links:
13751            RangeReader._process_link(link, obj)
13752
13753        # Discard the end tag:
13754        reader.read()
13755
13756        return obj
13757
13758    @staticmethod
13759    def read_many(reader):
13760        # Do nothing if there aren't more tags:
13761        objs = List()
13762        if not reader.forward():
13763            return objs
13764
13765        # Process the attributes:
13766        objs.href = reader.get_attribute('href')
13767
13768        # Discard the start tag:
13769        empty = reader.empty_element()
13770        reader.read()
13771        if empty:
13772            return objs
13773
13774        # Process the inner elements:
13775        while reader.forward():
13776            objs.append(RangeReader.read_one(reader))
13777
13778        # Discard the end tag:
13779        reader.read()
13780
13781        return objs
13782
13783
13784class RateReader(Reader):
13785
13786    def __init__(self):
13787        super(RateReader, self).__init__()
13788
13789    @staticmethod
13790    def read_one(reader):
13791        # Do nothing if there aren't more tags:
13792        if not reader.forward():
13793            return None
13794
13795        # Create the object:
13796        obj = types.Rate()
13797
13798        # Process the attributes:
13799        obj.href = reader.get_attribute('href')
13800
13801        # Discard the start tag:
13802        empty = reader.empty_element()
13803        reader.read()
13804        if empty:
13805            return obj
13806
13807        # Process the inner elements:
13808        links = []
13809        while reader.forward():
13810            tag = reader.node_name()
13811            if tag == 'bytes':
13812                obj.bytes = Reader.read_integer(reader)
13813            elif tag == 'period':
13814                obj.period = Reader.read_integer(reader)
13815            else:
13816                reader.next_element()
13817        for link in links:
13818            RateReader._process_link(link, obj)
13819
13820        # Discard the end tag:
13821        reader.read()
13822
13823        return obj
13824
13825    @staticmethod
13826    def read_many(reader):
13827        # Do nothing if there aren't more tags:
13828        objs = List()
13829        if not reader.forward():
13830            return objs
13831
13832        # Process the attributes:
13833        objs.href = reader.get_attribute('href')
13834
13835        # Discard the start tag:
13836        empty = reader.empty_element()
13837        reader.read()
13838        if empty:
13839            return objs
13840
13841        # Process the inner elements:
13842        while reader.forward():
13843            objs.append(RateReader.read_one(reader))
13844
13845        # Discard the end tag:
13846        reader.read()
13847
13848        return objs
13849
13850
13851class RegistrationAffinityGroupMappingReader(Reader):
13852
13853    def __init__(self):
13854        super(RegistrationAffinityGroupMappingReader, self).__init__()
13855
13856    @staticmethod
13857    def read_one(reader):
13858        # Do nothing if there aren't more tags:
13859        if not reader.forward():
13860            return None
13861
13862        # Create the object:
13863        obj = types.RegistrationAffinityGroupMapping()
13864
13865        # Process the attributes:
13866        obj.href = reader.get_attribute('href')
13867
13868        # Discard the start tag:
13869        empty = reader.empty_element()
13870        reader.read()
13871        if empty:
13872            return obj
13873
13874        # Process the inner elements:
13875        links = []
13876        while reader.forward():
13877            tag = reader.node_name()
13878            if tag == 'from':
13879                obj.from_ = AffinityGroupReader.read_one(reader)
13880            elif tag == 'to':
13881                obj.to = AffinityGroupReader.read_one(reader)
13882            else:
13883                reader.next_element()
13884        for link in links:
13885            RegistrationAffinityGroupMappingReader._process_link(link, obj)
13886
13887        # Discard the end tag:
13888        reader.read()
13889
13890        return obj
13891
13892    @staticmethod
13893    def read_many(reader):
13894        # Do nothing if there aren't more tags:
13895        objs = List()
13896        if not reader.forward():
13897            return objs
13898
13899        # Process the attributes:
13900        objs.href = reader.get_attribute('href')
13901
13902        # Discard the start tag:
13903        empty = reader.empty_element()
13904        reader.read()
13905        if empty:
13906            return objs
13907
13908        # Process the inner elements:
13909        while reader.forward():
13910            objs.append(RegistrationAffinityGroupMappingReader.read_one(reader))
13911
13912        # Discard the end tag:
13913        reader.read()
13914
13915        return objs
13916
13917
13918class RegistrationAffinityLabelMappingReader(Reader):
13919
13920    def __init__(self):
13921        super(RegistrationAffinityLabelMappingReader, self).__init__()
13922
13923    @staticmethod
13924    def read_one(reader):
13925        # Do nothing if there aren't more tags:
13926        if not reader.forward():
13927            return None
13928
13929        # Create the object:
13930        obj = types.RegistrationAffinityLabelMapping()
13931
13932        # Process the attributes:
13933        obj.href = reader.get_attribute('href')
13934
13935        # Discard the start tag:
13936        empty = reader.empty_element()
13937        reader.read()
13938        if empty:
13939            return obj
13940
13941        # Process the inner elements:
13942        links = []
13943        while reader.forward():
13944            tag = reader.node_name()
13945            if tag == 'from':
13946                obj.from_ = AffinityLabelReader.read_one(reader)
13947            elif tag == 'to':
13948                obj.to = AffinityLabelReader.read_one(reader)
13949            else:
13950                reader.next_element()
13951        for link in links:
13952            RegistrationAffinityLabelMappingReader._process_link(link, obj)
13953
13954        # Discard the end tag:
13955        reader.read()
13956
13957        return obj
13958
13959    @staticmethod
13960    def read_many(reader):
13961        # Do nothing if there aren't more tags:
13962        objs = List()
13963        if not reader.forward():
13964            return objs
13965
13966        # Process the attributes:
13967        objs.href = reader.get_attribute('href')
13968
13969        # Discard the start tag:
13970        empty = reader.empty_element()
13971        reader.read()
13972        if empty:
13973            return objs
13974
13975        # Process the inner elements:
13976        while reader.forward():
13977            objs.append(RegistrationAffinityLabelMappingReader.read_one(reader))
13978
13979        # Discard the end tag:
13980        reader.read()
13981
13982        return objs
13983
13984
13985class RegistrationClusterMappingReader(Reader):
13986
13987    def __init__(self):
13988        super(RegistrationClusterMappingReader, self).__init__()
13989
13990    @staticmethod
13991    def read_one(reader):
13992        # Do nothing if there aren't more tags:
13993        if not reader.forward():
13994            return None
13995
13996        # Create the object:
13997        obj = types.RegistrationClusterMapping()
13998
13999        # Process the attributes:
14000        obj.href = reader.get_attribute('href')
14001
14002        # Discard the start tag:
14003        empty = reader.empty_element()
14004        reader.read()
14005        if empty:
14006            return obj
14007
14008        # Process the inner elements:
14009        links = []
14010        while reader.forward():
14011            tag = reader.node_name()
14012            if tag == 'from':
14013                obj.from_ = ClusterReader.read_one(reader)
14014            elif tag == 'to':
14015                obj.to = ClusterReader.read_one(reader)
14016            else:
14017                reader.next_element()
14018        for link in links:
14019            RegistrationClusterMappingReader._process_link(link, obj)
14020
14021        # Discard the end tag:
14022        reader.read()
14023
14024        return obj
14025
14026    @staticmethod
14027    def read_many(reader):
14028        # Do nothing if there aren't more tags:
14029        objs = List()
14030        if not reader.forward():
14031            return objs
14032
14033        # Process the attributes:
14034        objs.href = reader.get_attribute('href')
14035
14036        # Discard the start tag:
14037        empty = reader.empty_element()
14038        reader.read()
14039        if empty:
14040            return objs
14041
14042        # Process the inner elements:
14043        while reader.forward():
14044            objs.append(RegistrationClusterMappingReader.read_one(reader))
14045
14046        # Discard the end tag:
14047        reader.read()
14048
14049        return objs
14050
14051
14052class RegistrationConfigurationReader(Reader):
14053
14054    def __init__(self):
14055        super(RegistrationConfigurationReader, self).__init__()
14056
14057    @staticmethod
14058    def read_one(reader):
14059        # Do nothing if there aren't more tags:
14060        if not reader.forward():
14061            return None
14062
14063        # Create the object:
14064        obj = types.RegistrationConfiguration()
14065
14066        # Process the attributes:
14067        obj.href = reader.get_attribute('href')
14068
14069        # Discard the start tag:
14070        empty = reader.empty_element()
14071        reader.read()
14072        if empty:
14073            return obj
14074
14075        # Process the inner elements:
14076        links = []
14077        while reader.forward():
14078            tag = reader.node_name()
14079            if tag == 'affinity_group_mappings':
14080                obj.affinity_group_mappings = RegistrationAffinityGroupMappingReader.read_many(reader)
14081            elif tag == 'affinity_label_mappings':
14082                obj.affinity_label_mappings = RegistrationAffinityLabelMappingReader.read_many(reader)
14083            elif tag == 'cluster_mappings':
14084                obj.cluster_mappings = RegistrationClusterMappingReader.read_many(reader)
14085            elif tag == 'domain_mappings':
14086                obj.domain_mappings = RegistrationDomainMappingReader.read_many(reader)
14087            elif tag == 'lun_mappings':
14088                obj.lun_mappings = RegistrationLunMappingReader.read_many(reader)
14089            elif tag == 'role_mappings':
14090                obj.role_mappings = RegistrationRoleMappingReader.read_many(reader)
14091            elif tag == 'vnic_profile_mappings':
14092                obj.vnic_profile_mappings = RegistrationVnicProfileMappingReader.read_many(reader)
14093            else:
14094                reader.next_element()
14095        for link in links:
14096            RegistrationConfigurationReader._process_link(link, obj)
14097
14098        # Discard the end tag:
14099        reader.read()
14100
14101        return obj
14102
14103    @staticmethod
14104    def read_many(reader):
14105        # Do nothing if there aren't more tags:
14106        objs = List()
14107        if not reader.forward():
14108            return objs
14109
14110        # Process the attributes:
14111        objs.href = reader.get_attribute('href')
14112
14113        # Discard the start tag:
14114        empty = reader.empty_element()
14115        reader.read()
14116        if empty:
14117            return objs
14118
14119        # Process the inner elements:
14120        while reader.forward():
14121            objs.append(RegistrationConfigurationReader.read_one(reader))
14122
14123        # Discard the end tag:
14124        reader.read()
14125
14126        return objs
14127
14128
14129class RegistrationDomainMappingReader(Reader):
14130
14131    def __init__(self):
14132        super(RegistrationDomainMappingReader, self).__init__()
14133
14134    @staticmethod
14135    def read_one(reader):
14136        # Do nothing if there aren't more tags:
14137        if not reader.forward():
14138            return None
14139
14140        # Create the object:
14141        obj = types.RegistrationDomainMapping()
14142
14143        # Process the attributes:
14144        obj.href = reader.get_attribute('href')
14145
14146        # Discard the start tag:
14147        empty = reader.empty_element()
14148        reader.read()
14149        if empty:
14150            return obj
14151
14152        # Process the inner elements:
14153        links = []
14154        while reader.forward():
14155            tag = reader.node_name()
14156            if tag == 'from':
14157                obj.from_ = DomainReader.read_one(reader)
14158            elif tag == 'to':
14159                obj.to = DomainReader.read_one(reader)
14160            else:
14161                reader.next_element()
14162        for link in links:
14163            RegistrationDomainMappingReader._process_link(link, obj)
14164
14165        # Discard the end tag:
14166        reader.read()
14167
14168        return obj
14169
14170    @staticmethod
14171    def read_many(reader):
14172        # Do nothing if there aren't more tags:
14173        objs = List()
14174        if not reader.forward():
14175            return objs
14176
14177        # Process the attributes:
14178        objs.href = reader.get_attribute('href')
14179
14180        # Discard the start tag:
14181        empty = reader.empty_element()
14182        reader.read()
14183        if empty:
14184            return objs
14185
14186        # Process the inner elements:
14187        while reader.forward():
14188            objs.append(RegistrationDomainMappingReader.read_one(reader))
14189
14190        # Discard the end tag:
14191        reader.read()
14192
14193        return objs
14194
14195
14196class RegistrationLunMappingReader(Reader):
14197
14198    def __init__(self):
14199        super(RegistrationLunMappingReader, self).__init__()
14200
14201    @staticmethod
14202    def read_one(reader):
14203        # Do nothing if there aren't more tags:
14204        if not reader.forward():
14205            return None
14206
14207        # Create the object:
14208        obj = types.RegistrationLunMapping()
14209
14210        # Process the attributes:
14211        obj.href = reader.get_attribute('href')
14212
14213        # Discard the start tag:
14214        empty = reader.empty_element()
14215        reader.read()
14216        if empty:
14217            return obj
14218
14219        # Process the inner elements:
14220        links = []
14221        while reader.forward():
14222            tag = reader.node_name()
14223            if tag == 'from':
14224                obj.from_ = DiskReader.read_one(reader)
14225            elif tag == 'to':
14226                obj.to = DiskReader.read_one(reader)
14227            else:
14228                reader.next_element()
14229        for link in links:
14230            RegistrationLunMappingReader._process_link(link, obj)
14231
14232        # Discard the end tag:
14233        reader.read()
14234
14235        return obj
14236
14237    @staticmethod
14238    def read_many(reader):
14239        # Do nothing if there aren't more tags:
14240        objs = List()
14241        if not reader.forward():
14242            return objs
14243
14244        # Process the attributes:
14245        objs.href = reader.get_attribute('href')
14246
14247        # Discard the start tag:
14248        empty = reader.empty_element()
14249        reader.read()
14250        if empty:
14251            return objs
14252
14253        # Process the inner elements:
14254        while reader.forward():
14255            objs.append(RegistrationLunMappingReader.read_one(reader))
14256
14257        # Discard the end tag:
14258        reader.read()
14259
14260        return objs
14261
14262
14263class RegistrationRoleMappingReader(Reader):
14264
14265    def __init__(self):
14266        super(RegistrationRoleMappingReader, self).__init__()
14267
14268    @staticmethod
14269    def read_one(reader):
14270        # Do nothing if there aren't more tags:
14271        if not reader.forward():
14272            return None
14273
14274        # Create the object:
14275        obj = types.RegistrationRoleMapping()
14276
14277        # Process the attributes:
14278        obj.href = reader.get_attribute('href')
14279
14280        # Discard the start tag:
14281        empty = reader.empty_element()
14282        reader.read()
14283        if empty:
14284            return obj
14285
14286        # Process the inner elements:
14287        links = []
14288        while reader.forward():
14289            tag = reader.node_name()
14290            if tag == 'from':
14291                obj.from_ = RoleReader.read_one(reader)
14292            elif tag == 'to':
14293                obj.to = RoleReader.read_one(reader)
14294            else:
14295                reader.next_element()
14296        for link in links:
14297            RegistrationRoleMappingReader._process_link(link, obj)
14298
14299        # Discard the end tag:
14300        reader.read()
14301
14302        return obj
14303
14304    @staticmethod
14305    def read_many(reader):
14306        # Do nothing if there aren't more tags:
14307        objs = List()
14308        if not reader.forward():
14309            return objs
14310
14311        # Process the attributes:
14312        objs.href = reader.get_attribute('href')
14313
14314        # Discard the start tag:
14315        empty = reader.empty_element()
14316        reader.read()
14317        if empty:
14318            return objs
14319
14320        # Process the inner elements:
14321        while reader.forward():
14322            objs.append(RegistrationRoleMappingReader.read_one(reader))
14323
14324        # Discard the end tag:
14325        reader.read()
14326
14327        return objs
14328
14329
14330class RegistrationVnicProfileMappingReader(Reader):
14331
14332    def __init__(self):
14333        super(RegistrationVnicProfileMappingReader, self).__init__()
14334
14335    @staticmethod
14336    def read_one(reader):
14337        # Do nothing if there aren't more tags:
14338        if not reader.forward():
14339            return None
14340
14341        # Create the object:
14342        obj = types.RegistrationVnicProfileMapping()
14343
14344        # Process the attributes:
14345        obj.href = reader.get_attribute('href')
14346
14347        # Discard the start tag:
14348        empty = reader.empty_element()
14349        reader.read()
14350        if empty:
14351            return obj
14352
14353        # Process the inner elements:
14354        links = []
14355        while reader.forward():
14356            tag = reader.node_name()
14357            if tag == 'from':
14358                obj.from_ = VnicProfileReader.read_one(reader)
14359            elif tag == 'to':
14360                obj.to = VnicProfileReader.read_one(reader)
14361            else:
14362                reader.next_element()
14363        for link in links:
14364            RegistrationVnicProfileMappingReader._process_link(link, obj)
14365
14366        # Discard the end tag:
14367        reader.read()
14368
14369        return obj
14370
14371    @staticmethod
14372    def read_many(reader):
14373        # Do nothing if there aren't more tags:
14374        objs = List()
14375        if not reader.forward():
14376            return objs
14377
14378        # Process the attributes:
14379        objs.href = reader.get_attribute('href')
14380
14381        # Discard the start tag:
14382        empty = reader.empty_element()
14383        reader.read()
14384        if empty:
14385            return objs
14386
14387        # Process the inner elements:
14388        while reader.forward():
14389            objs.append(RegistrationVnicProfileMappingReader.read_one(reader))
14390
14391        # Discard the end tag:
14392        reader.read()
14393
14394        return objs
14395
14396
14397class ReportedConfigurationReader(Reader):
14398
14399    def __init__(self):
14400        super(ReportedConfigurationReader, self).__init__()
14401
14402    @staticmethod
14403    def read_one(reader):
14404        # Do nothing if there aren't more tags:
14405        if not reader.forward():
14406            return None
14407
14408        # Create the object:
14409        obj = types.ReportedConfiguration()
14410
14411        # Process the attributes:
14412        obj.href = reader.get_attribute('href')
14413
14414        # Discard the start tag:
14415        empty = reader.empty_element()
14416        reader.read()
14417        if empty:
14418            return obj
14419
14420        # Process the inner elements:
14421        links = []
14422        while reader.forward():
14423            tag = reader.node_name()
14424            if tag == 'actual_value':
14425                obj.actual_value = Reader.read_string(reader)
14426            elif tag == 'expected_value':
14427                obj.expected_value = Reader.read_string(reader)
14428            elif tag == 'in_sync':
14429                obj.in_sync = Reader.read_boolean(reader)
14430            elif tag == 'name':
14431                obj.name = Reader.read_string(reader)
14432            else:
14433                reader.next_element()
14434        for link in links:
14435            ReportedConfigurationReader._process_link(link, obj)
14436
14437        # Discard the end tag:
14438        reader.read()
14439
14440        return obj
14441
14442    @staticmethod
14443    def read_many(reader):
14444        # Do nothing if there aren't more tags:
14445        objs = List()
14446        if not reader.forward():
14447            return objs
14448
14449        # Process the attributes:
14450        objs.href = reader.get_attribute('href')
14451
14452        # Discard the start tag:
14453        empty = reader.empty_element()
14454        reader.read()
14455        if empty:
14456            return objs
14457
14458        # Process the inner elements:
14459        while reader.forward():
14460            objs.append(ReportedConfigurationReader.read_one(reader))
14461
14462        # Discard the end tag:
14463        reader.read()
14464
14465        return objs
14466
14467
14468class ReportedDeviceReader(Reader):
14469
14470    def __init__(self):
14471        super(ReportedDeviceReader, self).__init__()
14472
14473    @staticmethod
14474    def read_one(reader):
14475        # Do nothing if there aren't more tags:
14476        if not reader.forward():
14477            return None
14478
14479        # Create the object:
14480        obj = types.ReportedDevice()
14481
14482        # Process the attributes:
14483        obj.href = reader.get_attribute('href')
14484        value = reader.get_attribute('id')
14485        if value is not None:
14486            obj.id = value
14487
14488        # Discard the start tag:
14489        empty = reader.empty_element()
14490        reader.read()
14491        if empty:
14492            return obj
14493
14494        # Process the inner elements:
14495        links = []
14496        while reader.forward():
14497            tag = reader.node_name()
14498            if tag == 'comment':
14499                obj.comment = Reader.read_string(reader)
14500            elif tag == 'description':
14501                obj.description = Reader.read_string(reader)
14502            elif tag == 'ips':
14503                obj.ips = IpReader.read_many(reader)
14504            elif tag == 'mac':
14505                obj.mac = MacReader.read_one(reader)
14506            elif tag == 'name':
14507                obj.name = Reader.read_string(reader)
14508            elif tag == 'type':
14509                obj.type = Reader.read_enum(types.ReportedDeviceType, reader)
14510            elif tag == 'vm':
14511                obj.vm = VmReader.read_one(reader)
14512            else:
14513                reader.next_element()
14514        for link in links:
14515            ReportedDeviceReader._process_link(link, obj)
14516
14517        # Discard the end tag:
14518        reader.read()
14519
14520        return obj
14521
14522    @staticmethod
14523    def read_many(reader):
14524        # Do nothing if there aren't more tags:
14525        objs = List()
14526        if not reader.forward():
14527            return objs
14528
14529        # Process the attributes:
14530        objs.href = reader.get_attribute('href')
14531
14532        # Discard the start tag:
14533        empty = reader.empty_element()
14534        reader.read()
14535        if empty:
14536            return objs
14537
14538        # Process the inner elements:
14539        while reader.forward():
14540            objs.append(ReportedDeviceReader.read_one(reader))
14541
14542        # Discard the end tag:
14543        reader.read()
14544
14545        return objs
14546
14547
14548class RngDeviceReader(Reader):
14549
14550    def __init__(self):
14551        super(RngDeviceReader, self).__init__()
14552
14553    @staticmethod
14554    def read_one(reader):
14555        # Do nothing if there aren't more tags:
14556        if not reader.forward():
14557            return None
14558
14559        # Create the object:
14560        obj = types.RngDevice()
14561
14562        # Process the attributes:
14563        obj.href = reader.get_attribute('href')
14564
14565        # Discard the start tag:
14566        empty = reader.empty_element()
14567        reader.read()
14568        if empty:
14569            return obj
14570
14571        # Process the inner elements:
14572        links = []
14573        while reader.forward():
14574            tag = reader.node_name()
14575            if tag == 'rate':
14576                obj.rate = RateReader.read_one(reader)
14577            elif tag == 'source':
14578                obj.source = Reader.read_enum(types.RngSource, reader)
14579            else:
14580                reader.next_element()
14581        for link in links:
14582            RngDeviceReader._process_link(link, obj)
14583
14584        # Discard the end tag:
14585        reader.read()
14586
14587        return obj
14588
14589    @staticmethod
14590    def read_many(reader):
14591        # Do nothing if there aren't more tags:
14592        objs = List()
14593        if not reader.forward():
14594            return objs
14595
14596        # Process the attributes:
14597        objs.href = reader.get_attribute('href')
14598
14599        # Discard the start tag:
14600        empty = reader.empty_element()
14601        reader.read()
14602        if empty:
14603            return objs
14604
14605        # Process the inner elements:
14606        while reader.forward():
14607            objs.append(RngDeviceReader.read_one(reader))
14608
14609        # Discard the end tag:
14610        reader.read()
14611
14612        return objs
14613
14614
14615class RoleReader(Reader):
14616
14617    def __init__(self):
14618        super(RoleReader, self).__init__()
14619
14620    @staticmethod
14621    def read_one(reader):
14622        # Do nothing if there aren't more tags:
14623        if not reader.forward():
14624            return None
14625
14626        # Create the object:
14627        obj = types.Role()
14628
14629        # Process the attributes:
14630        obj.href = reader.get_attribute('href')
14631        value = reader.get_attribute('id')
14632        if value is not None:
14633            obj.id = value
14634
14635        # Discard the start tag:
14636        empty = reader.empty_element()
14637        reader.read()
14638        if empty:
14639            return obj
14640
14641        # Process the inner elements:
14642        links = []
14643        while reader.forward():
14644            tag = reader.node_name()
14645            if tag == 'administrative':
14646                obj.administrative = Reader.read_boolean(reader)
14647            elif tag == 'comment':
14648                obj.comment = Reader.read_string(reader)
14649            elif tag == 'description':
14650                obj.description = Reader.read_string(reader)
14651            elif tag == 'mutable':
14652                obj.mutable = Reader.read_boolean(reader)
14653            elif tag == 'name':
14654                obj.name = Reader.read_string(reader)
14655            elif tag == 'permits':
14656                obj.permits = PermitReader.read_many(reader)
14657            elif tag == 'user':
14658                obj.user = UserReader.read_one(reader)
14659            elif tag == 'link':
14660                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
14661                reader.next_element()
14662            else:
14663                reader.next_element()
14664        for link in links:
14665            RoleReader._process_link(link, obj)
14666
14667        # Discard the end tag:
14668        reader.read()
14669
14670        return obj
14671
14672    @staticmethod
14673    def read_many(reader):
14674        # Do nothing if there aren't more tags:
14675        objs = List()
14676        if not reader.forward():
14677            return objs
14678
14679        # Process the attributes:
14680        objs.href = reader.get_attribute('href')
14681
14682        # Discard the start tag:
14683        empty = reader.empty_element()
14684        reader.read()
14685        if empty:
14686            return objs
14687
14688        # Process the inner elements:
14689        while reader.forward():
14690            objs.append(RoleReader.read_one(reader))
14691
14692        # Discard the end tag:
14693        reader.read()
14694
14695        return objs
14696
14697    @staticmethod
14698    def _process_link(link, obj):
14699        # Process the attributes:
14700        rel = link[0]
14701        href = link[1]
14702        if href and rel:
14703            if rel == "permits":
14704                if obj.permits is not None:
14705                    obj.permits.href = href
14706                else:
14707                    obj.permits = List(href)
14708
14709
14710class SchedulingPolicyReader(Reader):
14711
14712    def __init__(self):
14713        super(SchedulingPolicyReader, self).__init__()
14714
14715    @staticmethod
14716    def read_one(reader):
14717        # Do nothing if there aren't more tags:
14718        if not reader.forward():
14719            return None
14720
14721        # Create the object:
14722        obj = types.SchedulingPolicy()
14723
14724        # Process the attributes:
14725        obj.href = reader.get_attribute('href')
14726        value = reader.get_attribute('id')
14727        if value is not None:
14728            obj.id = value
14729
14730        # Discard the start tag:
14731        empty = reader.empty_element()
14732        reader.read()
14733        if empty:
14734            return obj
14735
14736        # Process the inner elements:
14737        links = []
14738        while reader.forward():
14739            tag = reader.node_name()
14740            if tag == 'balances':
14741                obj.balances = BalanceReader.read_many(reader)
14742            elif tag == 'comment':
14743                obj.comment = Reader.read_string(reader)
14744            elif tag == 'default_policy':
14745                obj.default_policy = Reader.read_boolean(reader)
14746            elif tag == 'description':
14747                obj.description = Reader.read_string(reader)
14748            elif tag == 'filters':
14749                obj.filters = FilterReader.read_many(reader)
14750            elif tag == 'locked':
14751                obj.locked = Reader.read_boolean(reader)
14752            elif tag == 'name':
14753                obj.name = Reader.read_string(reader)
14754            elif tag == 'properties':
14755                obj.properties = PropertyReader.read_many(reader)
14756            elif tag == 'weight':
14757                obj.weight = WeightReader.read_many(reader)
14758            elif tag == 'link':
14759                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
14760                reader.next_element()
14761            else:
14762                reader.next_element()
14763        for link in links:
14764            SchedulingPolicyReader._process_link(link, obj)
14765
14766        # Discard the end tag:
14767        reader.read()
14768
14769        return obj
14770
14771    @staticmethod
14772    def read_many(reader):
14773        # Do nothing if there aren't more tags:
14774        objs = List()
14775        if not reader.forward():
14776            return objs
14777
14778        # Process the attributes:
14779        objs.href = reader.get_attribute('href')
14780
14781        # Discard the start tag:
14782        empty = reader.empty_element()
14783        reader.read()
14784        if empty:
14785            return objs
14786
14787        # Process the inner elements:
14788        while reader.forward():
14789            objs.append(SchedulingPolicyReader.read_one(reader))
14790
14791        # Discard the end tag:
14792        reader.read()
14793
14794        return objs
14795
14796    @staticmethod
14797    def _process_link(link, obj):
14798        # Process the attributes:
14799        rel = link[0]
14800        href = link[1]
14801        if href and rel:
14802            if rel == "balances":
14803                if obj.balances is not None:
14804                    obj.balances.href = href
14805                else:
14806                    obj.balances = List(href)
14807            elif rel == "filters":
14808                if obj.filters is not None:
14809                    obj.filters.href = href
14810                else:
14811                    obj.filters = List(href)
14812            elif rel == "weight":
14813                if obj.weight is not None:
14814                    obj.weight.href = href
14815                else:
14816                    obj.weight = List(href)
14817
14818
14819class SchedulingPolicyUnitReader(Reader):
14820
14821    def __init__(self):
14822        super(SchedulingPolicyUnitReader, self).__init__()
14823
14824    @staticmethod
14825    def read_one(reader):
14826        # Do nothing if there aren't more tags:
14827        if not reader.forward():
14828            return None
14829
14830        # Create the object:
14831        obj = types.SchedulingPolicyUnit()
14832
14833        # Process the attributes:
14834        obj.href = reader.get_attribute('href')
14835        value = reader.get_attribute('id')
14836        if value is not None:
14837            obj.id = value
14838
14839        # Discard the start tag:
14840        empty = reader.empty_element()
14841        reader.read()
14842        if empty:
14843            return obj
14844
14845        # Process the inner elements:
14846        links = []
14847        while reader.forward():
14848            tag = reader.node_name()
14849            if tag == 'comment':
14850                obj.comment = Reader.read_string(reader)
14851            elif tag == 'description':
14852                obj.description = Reader.read_string(reader)
14853            elif tag == 'enabled':
14854                obj.enabled = Reader.read_boolean(reader)
14855            elif tag == 'internal':
14856                obj.internal = Reader.read_boolean(reader)
14857            elif tag == 'name':
14858                obj.name = Reader.read_string(reader)
14859            elif tag == 'properties':
14860                obj.properties = PropertyReader.read_many(reader)
14861            elif tag == 'type':
14862                obj.type = Reader.read_enum(types.PolicyUnitType, reader)
14863            else:
14864                reader.next_element()
14865        for link in links:
14866            SchedulingPolicyUnitReader._process_link(link, obj)
14867
14868        # Discard the end tag:
14869        reader.read()
14870
14871        return obj
14872
14873    @staticmethod
14874    def read_many(reader):
14875        # Do nothing if there aren't more tags:
14876        objs = List()
14877        if not reader.forward():
14878            return objs
14879
14880        # Process the attributes:
14881        objs.href = reader.get_attribute('href')
14882
14883        # Discard the start tag:
14884        empty = reader.empty_element()
14885        reader.read()
14886        if empty:
14887            return objs
14888
14889        # Process the inner elements:
14890        while reader.forward():
14891            objs.append(SchedulingPolicyUnitReader.read_one(reader))
14892
14893        # Discard the end tag:
14894        reader.read()
14895
14896        return objs
14897
14898
14899class SeLinuxReader(Reader):
14900
14901    def __init__(self):
14902        super(SeLinuxReader, self).__init__()
14903
14904    @staticmethod
14905    def read_one(reader):
14906        # Do nothing if there aren't more tags:
14907        if not reader.forward():
14908            return None
14909
14910        # Create the object:
14911        obj = types.SeLinux()
14912
14913        # Process the attributes:
14914        obj.href = reader.get_attribute('href')
14915
14916        # Discard the start tag:
14917        empty = reader.empty_element()
14918        reader.read()
14919        if empty:
14920            return obj
14921
14922        # Process the inner elements:
14923        links = []
14924        while reader.forward():
14925            tag = reader.node_name()
14926            if tag == 'mode':
14927                obj.mode = Reader.read_enum(types.SeLinuxMode, reader)
14928            else:
14929                reader.next_element()
14930        for link in links:
14931            SeLinuxReader._process_link(link, obj)
14932
14933        # Discard the end tag:
14934        reader.read()
14935
14936        return obj
14937
14938    @staticmethod
14939    def read_many(reader):
14940        # Do nothing if there aren't more tags:
14941        objs = List()
14942        if not reader.forward():
14943            return objs
14944
14945        # Process the attributes:
14946        objs.href = reader.get_attribute('href')
14947
14948        # Discard the start tag:
14949        empty = reader.empty_element()
14950        reader.read()
14951        if empty:
14952            return objs
14953
14954        # Process the inner elements:
14955        while reader.forward():
14956            objs.append(SeLinuxReader.read_one(reader))
14957
14958        # Discard the end tag:
14959        reader.read()
14960
14961        return objs
14962
14963
14964class SerialNumberReader(Reader):
14965
14966    def __init__(self):
14967        super(SerialNumberReader, self).__init__()
14968
14969    @staticmethod
14970    def read_one(reader):
14971        # Do nothing if there aren't more tags:
14972        if not reader.forward():
14973            return None
14974
14975        # Create the object:
14976        obj = types.SerialNumber()
14977
14978        # Process the attributes:
14979        obj.href = reader.get_attribute('href')
14980
14981        # Discard the start tag:
14982        empty = reader.empty_element()
14983        reader.read()
14984        if empty:
14985            return obj
14986
14987        # Process the inner elements:
14988        links = []
14989        while reader.forward():
14990            tag = reader.node_name()
14991            if tag == 'policy':
14992                obj.policy = Reader.read_enum(types.SerialNumberPolicy, reader)
14993            elif tag == 'value':
14994                obj.value = Reader.read_string(reader)
14995            else:
14996                reader.next_element()
14997        for link in links:
14998            SerialNumberReader._process_link(link, obj)
14999
15000        # Discard the end tag:
15001        reader.read()
15002
15003        return obj
15004
15005    @staticmethod
15006    def read_many(reader):
15007        # Do nothing if there aren't more tags:
15008        objs = List()
15009        if not reader.forward():
15010            return objs
15011
15012        # Process the attributes:
15013        objs.href = reader.get_attribute('href')
15014
15015        # Discard the start tag:
15016        empty = reader.empty_element()
15017        reader.read()
15018        if empty:
15019            return objs
15020
15021        # Process the inner elements:
15022        while reader.forward():
15023            objs.append(SerialNumberReader.read_one(reader))
15024
15025        # Discard the end tag:
15026        reader.read()
15027
15028        return objs
15029
15030
15031class SessionReader(Reader):
15032
15033    def __init__(self):
15034        super(SessionReader, self).__init__()
15035
15036    @staticmethod
15037    def read_one(reader):
15038        # Do nothing if there aren't more tags:
15039        if not reader.forward():
15040            return None
15041
15042        # Create the object:
15043        obj = types.Session()
15044
15045        # Process the attributes:
15046        obj.href = reader.get_attribute('href')
15047        value = reader.get_attribute('id')
15048        if value is not None:
15049            obj.id = value
15050
15051        # Discard the start tag:
15052        empty = reader.empty_element()
15053        reader.read()
15054        if empty:
15055            return obj
15056
15057        # Process the inner elements:
15058        links = []
15059        while reader.forward():
15060            tag = reader.node_name()
15061            if tag == 'comment':
15062                obj.comment = Reader.read_string(reader)
15063            elif tag == 'console_user':
15064                obj.console_user = Reader.read_boolean(reader)
15065            elif tag == 'description':
15066                obj.description = Reader.read_string(reader)
15067            elif tag == 'ip':
15068                obj.ip = IpReader.read_one(reader)
15069            elif tag == 'name':
15070                obj.name = Reader.read_string(reader)
15071            elif tag == 'protocol':
15072                obj.protocol = Reader.read_string(reader)
15073            elif tag == 'user':
15074                obj.user = UserReader.read_one(reader)
15075            elif tag == 'vm':
15076                obj.vm = VmReader.read_one(reader)
15077            else:
15078                reader.next_element()
15079        for link in links:
15080            SessionReader._process_link(link, obj)
15081
15082        # Discard the end tag:
15083        reader.read()
15084
15085        return obj
15086
15087    @staticmethod
15088    def read_many(reader):
15089        # Do nothing if there aren't more tags:
15090        objs = List()
15091        if not reader.forward():
15092            return objs
15093
15094        # Process the attributes:
15095        objs.href = reader.get_attribute('href')
15096
15097        # Discard the start tag:
15098        empty = reader.empty_element()
15099        reader.read()
15100        if empty:
15101            return objs
15102
15103        # Process the inner elements:
15104        while reader.forward():
15105            objs.append(SessionReader.read_one(reader))
15106
15107        # Discard the end tag:
15108        reader.read()
15109
15110        return objs
15111
15112
15113class SkipIfConnectivityBrokenReader(Reader):
15114
15115    def __init__(self):
15116        super(SkipIfConnectivityBrokenReader, self).__init__()
15117
15118    @staticmethod
15119    def read_one(reader):
15120        # Do nothing if there aren't more tags:
15121        if not reader.forward():
15122            return None
15123
15124        # Create the object:
15125        obj = types.SkipIfConnectivityBroken()
15126
15127        # Process the attributes:
15128        obj.href = reader.get_attribute('href')
15129
15130        # Discard the start tag:
15131        empty = reader.empty_element()
15132        reader.read()
15133        if empty:
15134            return obj
15135
15136        # Process the inner elements:
15137        links = []
15138        while reader.forward():
15139            tag = reader.node_name()
15140            if tag == 'enabled':
15141                obj.enabled = Reader.read_boolean(reader)
15142            elif tag == 'threshold':
15143                obj.threshold = Reader.read_integer(reader)
15144            else:
15145                reader.next_element()
15146        for link in links:
15147            SkipIfConnectivityBrokenReader._process_link(link, obj)
15148
15149        # Discard the end tag:
15150        reader.read()
15151
15152        return obj
15153
15154    @staticmethod
15155    def read_many(reader):
15156        # Do nothing if there aren't more tags:
15157        objs = List()
15158        if not reader.forward():
15159            return objs
15160
15161        # Process the attributes:
15162        objs.href = reader.get_attribute('href')
15163
15164        # Discard the start tag:
15165        empty = reader.empty_element()
15166        reader.read()
15167        if empty:
15168            return objs
15169
15170        # Process the inner elements:
15171        while reader.forward():
15172            objs.append(SkipIfConnectivityBrokenReader.read_one(reader))
15173
15174        # Discard the end tag:
15175        reader.read()
15176
15177        return objs
15178
15179
15180class SkipIfSdActiveReader(Reader):
15181
15182    def __init__(self):
15183        super(SkipIfSdActiveReader, self).__init__()
15184
15185    @staticmethod
15186    def read_one(reader):
15187        # Do nothing if there aren't more tags:
15188        if not reader.forward():
15189            return None
15190
15191        # Create the object:
15192        obj = types.SkipIfSdActive()
15193
15194        # Process the attributes:
15195        obj.href = reader.get_attribute('href')
15196
15197        # Discard the start tag:
15198        empty = reader.empty_element()
15199        reader.read()
15200        if empty:
15201            return obj
15202
15203        # Process the inner elements:
15204        links = []
15205        while reader.forward():
15206            tag = reader.node_name()
15207            if tag == 'enabled':
15208                obj.enabled = Reader.read_boolean(reader)
15209            else:
15210                reader.next_element()
15211        for link in links:
15212            SkipIfSdActiveReader._process_link(link, obj)
15213
15214        # Discard the end tag:
15215        reader.read()
15216
15217        return obj
15218
15219    @staticmethod
15220    def read_many(reader):
15221        # Do nothing if there aren't more tags:
15222        objs = List()
15223        if not reader.forward():
15224            return objs
15225
15226        # Process the attributes:
15227        objs.href = reader.get_attribute('href')
15228
15229        # Discard the start tag:
15230        empty = reader.empty_element()
15231        reader.read()
15232        if empty:
15233            return objs
15234
15235        # Process the inner elements:
15236        while reader.forward():
15237            objs.append(SkipIfSdActiveReader.read_one(reader))
15238
15239        # Discard the end tag:
15240        reader.read()
15241
15242        return objs
15243
15244
15245class SnapshotReader(Reader):
15246
15247    def __init__(self):
15248        super(SnapshotReader, self).__init__()
15249
15250    @staticmethod
15251    def read_one(reader):
15252        # Do nothing if there aren't more tags:
15253        if not reader.forward():
15254            return None
15255
15256        # Create the object:
15257        obj = types.Snapshot()
15258
15259        # Process the attributes:
15260        obj.href = reader.get_attribute('href')
15261        value = reader.get_attribute('id')
15262        if value is not None:
15263            obj.id = value
15264
15265        # Discard the start tag:
15266        empty = reader.empty_element()
15267        reader.read()
15268        if empty:
15269            return obj
15270
15271        # Process the inner elements:
15272        links = []
15273        while reader.forward():
15274            tag = reader.node_name()
15275            if tag == 'affinity_labels':
15276                obj.affinity_labels = AffinityLabelReader.read_many(reader)
15277            elif tag == 'applications':
15278                obj.applications = ApplicationReader.read_many(reader)
15279            elif tag == 'auto_pinning_policy':
15280                obj.auto_pinning_policy = Reader.read_enum(types.AutoPinningPolicy, reader)
15281            elif tag == 'bios':
15282                obj.bios = BiosReader.read_one(reader)
15283            elif tag == 'cdroms':
15284                obj.cdroms = CdromReader.read_many(reader)
15285            elif tag == 'cluster':
15286                obj.cluster = ClusterReader.read_one(reader)
15287            elif tag == 'comment':
15288                obj.comment = Reader.read_string(reader)
15289            elif tag == 'console':
15290                obj.console = ConsoleReader.read_one(reader)
15291            elif tag == 'cpu':
15292                obj.cpu = CpuReader.read_one(reader)
15293            elif tag == 'cpu_pinning_policy':
15294                obj.cpu_pinning_policy = Reader.read_enum(types.CpuPinningPolicy, reader)
15295            elif tag == 'cpu_profile':
15296                obj.cpu_profile = CpuProfileReader.read_one(reader)
15297            elif tag == 'cpu_shares':
15298                obj.cpu_shares = Reader.read_integer(reader)
15299            elif tag == 'creation_time':
15300                obj.creation_time = Reader.read_date(reader)
15301            elif tag == 'custom_compatibility_version':
15302                obj.custom_compatibility_version = VersionReader.read_one(reader)
15303            elif tag == 'custom_cpu_model':
15304                obj.custom_cpu_model = Reader.read_string(reader)
15305            elif tag == 'custom_emulated_machine':
15306                obj.custom_emulated_machine = Reader.read_string(reader)
15307            elif tag == 'custom_properties':
15308                obj.custom_properties = CustomPropertyReader.read_many(reader)
15309            elif tag == 'date':
15310                obj.date = Reader.read_date(reader)
15311            elif tag == 'delete_protected':
15312                obj.delete_protected = Reader.read_boolean(reader)
15313            elif tag == 'description':
15314                obj.description = Reader.read_string(reader)
15315            elif tag == 'disk_attachments':
15316                obj.disk_attachments = DiskAttachmentReader.read_many(reader)
15317            elif tag == 'disks':
15318                obj.disks = DiskReader.read_many(reader)
15319            elif tag == 'display':
15320                obj.display = DisplayReader.read_one(reader)
15321            elif tag == 'domain':
15322                obj.domain = DomainReader.read_one(reader)
15323            elif tag == 'dynamic_cpu':
15324                obj.dynamic_cpu = DynamicCpuReader.read_one(reader)
15325            elif tag == 'external_host_provider':
15326                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
15327            elif tag == 'floppies':
15328                obj.floppies = FloppyReader.read_many(reader)
15329            elif tag == 'fqdn':
15330                obj.fqdn = Reader.read_string(reader)
15331            elif tag == 'graphics_consoles':
15332                obj.graphics_consoles = GraphicsConsoleReader.read_many(reader)
15333            elif tag == 'guest_operating_system':
15334                obj.guest_operating_system = GuestOperatingSystemReader.read_one(reader)
15335            elif tag == 'guest_time_zone':
15336                obj.guest_time_zone = TimeZoneReader.read_one(reader)
15337            elif tag == 'has_illegal_images':
15338                obj.has_illegal_images = Reader.read_boolean(reader)
15339            elif tag == 'high_availability':
15340                obj.high_availability = HighAvailabilityReader.read_one(reader)
15341            elif tag == 'host':
15342                obj.host = HostReader.read_one(reader)
15343            elif tag == 'host_devices':
15344                obj.host_devices = HostDeviceReader.read_many(reader)
15345            elif tag == 'initialization':
15346                obj.initialization = InitializationReader.read_one(reader)
15347            elif tag == 'instance_type':
15348                obj.instance_type = InstanceTypeReader.read_one(reader)
15349            elif tag == 'io':
15350                obj.io = IoReader.read_one(reader)
15351            elif tag == 'katello_errata':
15352                obj.katello_errata = KatelloErratumReader.read_many(reader)
15353            elif tag == 'large_icon':
15354                obj.large_icon = IconReader.read_one(reader)
15355            elif tag == 'lease':
15356                obj.lease = StorageDomainLeaseReader.read_one(reader)
15357            elif tag == 'mediated_devices':
15358                obj.mediated_devices = VmMediatedDeviceReader.read_many(reader)
15359            elif tag == 'memory':
15360                obj.memory = Reader.read_integer(reader)
15361            elif tag == 'memory_policy':
15362                obj.memory_policy = MemoryPolicyReader.read_one(reader)
15363            elif tag == 'migration':
15364                obj.migration = MigrationOptionsReader.read_one(reader)
15365            elif tag == 'migration_downtime':
15366                obj.migration_downtime = Reader.read_integer(reader)
15367            elif tag == 'multi_queues_enabled':
15368                obj.multi_queues_enabled = Reader.read_boolean(reader)
15369            elif tag == 'name':
15370                obj.name = Reader.read_string(reader)
15371            elif tag == 'next_run_configuration_exists':
15372                obj.next_run_configuration_exists = Reader.read_boolean(reader)
15373            elif tag == 'nics':
15374                obj.nics = NicReader.read_many(reader)
15375            elif tag == 'host_numa_nodes':
15376                obj.numa_nodes = NumaNodeReader.read_many(reader)
15377            elif tag == 'numa_tune_mode':
15378                obj.numa_tune_mode = Reader.read_enum(types.NumaTuneMode, reader)
15379            elif tag == 'origin':
15380                obj.origin = Reader.read_string(reader)
15381            elif tag == 'original_template':
15382                obj.original_template = TemplateReader.read_one(reader)
15383            elif tag == 'os':
15384                obj.os = OperatingSystemReader.read_one(reader)
15385            elif tag == 'payloads':
15386                obj.payloads = PayloadReader.read_many(reader)
15387            elif tag == 'permissions':
15388                obj.permissions = PermissionReader.read_many(reader)
15389            elif tag == 'persist_memorystate':
15390                obj.persist_memorystate = Reader.read_boolean(reader)
15391            elif tag == 'placement_policy':
15392                obj.placement_policy = VmPlacementPolicyReader.read_one(reader)
15393            elif tag == 'quota':
15394                obj.quota = QuotaReader.read_one(reader)
15395            elif tag == 'reported_devices':
15396                obj.reported_devices = ReportedDeviceReader.read_many(reader)
15397            elif tag == 'rng_device':
15398                obj.rng_device = RngDeviceReader.read_one(reader)
15399            elif tag == 'run_once':
15400                obj.run_once = Reader.read_boolean(reader)
15401            elif tag == 'serial_number':
15402                obj.serial_number = SerialNumberReader.read_one(reader)
15403            elif tag == 'sessions':
15404                obj.sessions = SessionReader.read_many(reader)
15405            elif tag == 'small_icon':
15406                obj.small_icon = IconReader.read_one(reader)
15407            elif tag == 'snapshot_status':
15408                obj.snapshot_status = Reader.read_enum(types.SnapshotStatus, reader)
15409            elif tag == 'snapshot_type':
15410                obj.snapshot_type = Reader.read_enum(types.SnapshotType, reader)
15411            elif tag == 'snapshots':
15412                obj.snapshots = SnapshotReader.read_many(reader)
15413            elif tag == 'soundcard_enabled':
15414                obj.soundcard_enabled = Reader.read_boolean(reader)
15415            elif tag == 'sso':
15416                obj.sso = SsoReader.read_one(reader)
15417            elif tag == 'start_paused':
15418                obj.start_paused = Reader.read_boolean(reader)
15419            elif tag == 'start_time':
15420                obj.start_time = Reader.read_date(reader)
15421            elif tag == 'stateless':
15422                obj.stateless = Reader.read_boolean(reader)
15423            elif tag == 'statistics':
15424                obj.statistics = StatisticReader.read_many(reader)
15425            elif tag == 'status':
15426                obj.status = Reader.read_enum(types.VmStatus, reader)
15427            elif tag == 'status_detail':
15428                obj.status_detail = Reader.read_string(reader)
15429            elif tag == 'stop_reason':
15430                obj.stop_reason = Reader.read_string(reader)
15431            elif tag == 'stop_time':
15432                obj.stop_time = Reader.read_date(reader)
15433            elif tag == 'storage_domain':
15434                obj.storage_domain = StorageDomainReader.read_one(reader)
15435            elif tag == 'storage_error_resume_behaviour':
15436                obj.storage_error_resume_behaviour = Reader.read_enum(types.VmStorageErrorResumeBehaviour, reader)
15437            elif tag == 'tags':
15438                obj.tags = TagReader.read_many(reader)
15439            elif tag == 'template':
15440                obj.template = TemplateReader.read_one(reader)
15441            elif tag == 'time_zone':
15442                obj.time_zone = TimeZoneReader.read_one(reader)
15443            elif tag == 'tpm_enabled':
15444                obj.tpm_enabled = Reader.read_boolean(reader)
15445            elif tag == 'tunnel_migration':
15446                obj.tunnel_migration = Reader.read_boolean(reader)
15447            elif tag == 'type':
15448                obj.type = Reader.read_enum(types.VmType, reader)
15449            elif tag == 'usb':
15450                obj.usb = UsbReader.read_one(reader)
15451            elif tag == 'use_latest_template_version':
15452                obj.use_latest_template_version = Reader.read_boolean(reader)
15453            elif tag == 'virtio_scsi':
15454                obj.virtio_scsi = VirtioScsiReader.read_one(reader)
15455            elif tag == 'virtio_scsi_multi_queues':
15456                obj.virtio_scsi_multi_queues = Reader.read_integer(reader)
15457            elif tag == 'virtio_scsi_multi_queues_enabled':
15458                obj.virtio_scsi_multi_queues_enabled = Reader.read_boolean(reader)
15459            elif tag == 'vm':
15460                obj.vm = VmReader.read_one(reader)
15461            elif tag == 'vm_pool':
15462                obj.vm_pool = VmPoolReader.read_one(reader)
15463            elif tag == 'watchdogs':
15464                obj.watchdogs = WatchdogReader.read_many(reader)
15465            elif tag == 'link':
15466                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
15467                reader.next_element()
15468            else:
15469                reader.next_element()
15470        for link in links:
15471            SnapshotReader._process_link(link, obj)
15472
15473        # Discard the end tag:
15474        reader.read()
15475
15476        return obj
15477
15478    @staticmethod
15479    def read_many(reader):
15480        # Do nothing if there aren't more tags:
15481        objs = List()
15482        if not reader.forward():
15483            return objs
15484
15485        # Process the attributes:
15486        objs.href = reader.get_attribute('href')
15487
15488        # Discard the start tag:
15489        empty = reader.empty_element()
15490        reader.read()
15491        if empty:
15492            return objs
15493
15494        # Process the inner elements:
15495        while reader.forward():
15496            objs.append(SnapshotReader.read_one(reader))
15497
15498        # Discard the end tag:
15499        reader.read()
15500
15501        return objs
15502
15503    @staticmethod
15504    def _process_link(link, obj):
15505        # Process the attributes:
15506        rel = link[0]
15507        href = link[1]
15508        if href and rel:
15509            if rel == "affinitylabels":
15510                if obj.affinity_labels is not None:
15511                    obj.affinity_labels.href = href
15512                else:
15513                    obj.affinity_labels = List(href)
15514            elif rel == "applications":
15515                if obj.applications is not None:
15516                    obj.applications.href = href
15517                else:
15518                    obj.applications = List(href)
15519            elif rel == "cdroms":
15520                if obj.cdroms is not None:
15521                    obj.cdroms.href = href
15522                else:
15523                    obj.cdroms = List(href)
15524            elif rel == "diskattachments":
15525                if obj.disk_attachments is not None:
15526                    obj.disk_attachments.href = href
15527                else:
15528                    obj.disk_attachments = List(href)
15529            elif rel == "disks":
15530                if obj.disks is not None:
15531                    obj.disks.href = href
15532                else:
15533                    obj.disks = List(href)
15534            elif rel == "floppies":
15535                if obj.floppies is not None:
15536                    obj.floppies.href = href
15537                else:
15538                    obj.floppies = List(href)
15539            elif rel == "graphicsconsoles":
15540                if obj.graphics_consoles is not None:
15541                    obj.graphics_consoles.href = href
15542                else:
15543                    obj.graphics_consoles = List(href)
15544            elif rel == "hostdevices":
15545                if obj.host_devices is not None:
15546                    obj.host_devices.href = href
15547                else:
15548                    obj.host_devices = List(href)
15549            elif rel == "katelloerrata":
15550                if obj.katello_errata is not None:
15551                    obj.katello_errata.href = href
15552                else:
15553                    obj.katello_errata = List(href)
15554            elif rel == "mediateddevices":
15555                if obj.mediated_devices is not None:
15556                    obj.mediated_devices.href = href
15557                else:
15558                    obj.mediated_devices = List(href)
15559            elif rel == "nics":
15560                if obj.nics is not None:
15561                    obj.nics.href = href
15562                else:
15563                    obj.nics = List(href)
15564            elif rel == "numanodes":
15565                if obj.numa_nodes is not None:
15566                    obj.numa_nodes.href = href
15567                else:
15568                    obj.numa_nodes = List(href)
15569            elif rel == "permissions":
15570                if obj.permissions is not None:
15571                    obj.permissions.href = href
15572                else:
15573                    obj.permissions = List(href)
15574            elif rel == "reporteddevices":
15575                if obj.reported_devices is not None:
15576                    obj.reported_devices.href = href
15577                else:
15578                    obj.reported_devices = List(href)
15579            elif rel == "sessions":
15580                if obj.sessions is not None:
15581                    obj.sessions.href = href
15582                else:
15583                    obj.sessions = List(href)
15584            elif rel == "snapshots":
15585                if obj.snapshots is not None:
15586                    obj.snapshots.href = href
15587                else:
15588                    obj.snapshots = List(href)
15589            elif rel == "statistics":
15590                if obj.statistics is not None:
15591                    obj.statistics.href = href
15592                else:
15593                    obj.statistics = List(href)
15594            elif rel == "tags":
15595                if obj.tags is not None:
15596                    obj.tags.href = href
15597                else:
15598                    obj.tags = List(href)
15599            elif rel == "watchdogs":
15600                if obj.watchdogs is not None:
15601                    obj.watchdogs.href = href
15602                else:
15603                    obj.watchdogs = List(href)
15604
15605
15606class SpecialObjectsReader(Reader):
15607
15608    def __init__(self):
15609        super(SpecialObjectsReader, self).__init__()
15610
15611    @staticmethod
15612    def read_one(reader):
15613        # Do nothing if there aren't more tags:
15614        if not reader.forward():
15615            return None
15616
15617        # Create the object:
15618        obj = types.SpecialObjects()
15619
15620        # Process the attributes:
15621        obj.href = reader.get_attribute('href')
15622
15623        # Discard the start tag:
15624        empty = reader.empty_element()
15625        reader.read()
15626        if empty:
15627            return obj
15628
15629        # Process the inner elements:
15630        links = []
15631        while reader.forward():
15632            tag = reader.node_name()
15633            if tag == 'blank_template':
15634                obj.blank_template = TemplateReader.read_one(reader)
15635            elif tag == 'root_tag':
15636                obj.root_tag = TagReader.read_one(reader)
15637            else:
15638                reader.next_element()
15639        for link in links:
15640            SpecialObjectsReader._process_link(link, obj)
15641
15642        # Discard the end tag:
15643        reader.read()
15644
15645        return obj
15646
15647    @staticmethod
15648    def read_many(reader):
15649        # Do nothing if there aren't more tags:
15650        objs = List()
15651        if not reader.forward():
15652            return objs
15653
15654        # Process the attributes:
15655        objs.href = reader.get_attribute('href')
15656
15657        # Discard the start tag:
15658        empty = reader.empty_element()
15659        reader.read()
15660        if empty:
15661            return objs
15662
15663        # Process the inner elements:
15664        while reader.forward():
15665            objs.append(SpecialObjectsReader.read_one(reader))
15666
15667        # Discard the end tag:
15668        reader.read()
15669
15670        return objs
15671
15672
15673class SpmReader(Reader):
15674
15675    def __init__(self):
15676        super(SpmReader, self).__init__()
15677
15678    @staticmethod
15679    def read_one(reader):
15680        # Do nothing if there aren't more tags:
15681        if not reader.forward():
15682            return None
15683
15684        # Create the object:
15685        obj = types.Spm()
15686
15687        # Process the attributes:
15688        obj.href = reader.get_attribute('href')
15689
15690        # Discard the start tag:
15691        empty = reader.empty_element()
15692        reader.read()
15693        if empty:
15694            return obj
15695
15696        # Process the inner elements:
15697        links = []
15698        while reader.forward():
15699            tag = reader.node_name()
15700            if tag == 'priority':
15701                obj.priority = Reader.read_integer(reader)
15702            elif tag == 'status':
15703                obj.status = Reader.read_enum(types.SpmStatus, reader)
15704            else:
15705                reader.next_element()
15706        for link in links:
15707            SpmReader._process_link(link, obj)
15708
15709        # Discard the end tag:
15710        reader.read()
15711
15712        return obj
15713
15714    @staticmethod
15715    def read_many(reader):
15716        # Do nothing if there aren't more tags:
15717        objs = List()
15718        if not reader.forward():
15719            return objs
15720
15721        # Process the attributes:
15722        objs.href = reader.get_attribute('href')
15723
15724        # Discard the start tag:
15725        empty = reader.empty_element()
15726        reader.read()
15727        if empty:
15728            return objs
15729
15730        # Process the inner elements:
15731        while reader.forward():
15732            objs.append(SpmReader.read_one(reader))
15733
15734        # Discard the end tag:
15735        reader.read()
15736
15737        return objs
15738
15739
15740class SshReader(Reader):
15741
15742    def __init__(self):
15743        super(SshReader, self).__init__()
15744
15745    @staticmethod
15746    def read_one(reader):
15747        # Do nothing if there aren't more tags:
15748        if not reader.forward():
15749            return None
15750
15751        # Create the object:
15752        obj = types.Ssh()
15753
15754        # Process the attributes:
15755        obj.href = reader.get_attribute('href')
15756        value = reader.get_attribute('id')
15757        if value is not None:
15758            obj.id = value
15759
15760        # Discard the start tag:
15761        empty = reader.empty_element()
15762        reader.read()
15763        if empty:
15764            return obj
15765
15766        # Process the inner elements:
15767        links = []
15768        while reader.forward():
15769            tag = reader.node_name()
15770            if tag == 'authentication_method':
15771                obj.authentication_method = Reader.read_enum(types.SshAuthenticationMethod, reader)
15772            elif tag == 'comment':
15773                obj.comment = Reader.read_string(reader)
15774            elif tag == 'description':
15775                obj.description = Reader.read_string(reader)
15776            elif tag == 'fingerprint':
15777                obj.fingerprint = Reader.read_string(reader)
15778            elif tag == 'name':
15779                obj.name = Reader.read_string(reader)
15780            elif tag == 'port':
15781                obj.port = Reader.read_integer(reader)
15782            elif tag == 'public_key':
15783                obj.public_key = Reader.read_string(reader)
15784            elif tag == 'user':
15785                obj.user = UserReader.read_one(reader)
15786            else:
15787                reader.next_element()
15788        for link in links:
15789            SshReader._process_link(link, obj)
15790
15791        # Discard the end tag:
15792        reader.read()
15793
15794        return obj
15795
15796    @staticmethod
15797    def read_many(reader):
15798        # Do nothing if there aren't more tags:
15799        objs = List()
15800        if not reader.forward():
15801            return objs
15802
15803        # Process the attributes:
15804        objs.href = reader.get_attribute('href')
15805
15806        # Discard the start tag:
15807        empty = reader.empty_element()
15808        reader.read()
15809        if empty:
15810            return objs
15811
15812        # Process the inner elements:
15813        while reader.forward():
15814            objs.append(SshReader.read_one(reader))
15815
15816        # Discard the end tag:
15817        reader.read()
15818
15819        return objs
15820
15821
15822class SshPublicKeyReader(Reader):
15823
15824    def __init__(self):
15825        super(SshPublicKeyReader, self).__init__()
15826
15827    @staticmethod
15828    def read_one(reader):
15829        # Do nothing if there aren't more tags:
15830        if not reader.forward():
15831            return None
15832
15833        # Create the object:
15834        obj = types.SshPublicKey()
15835
15836        # Process the attributes:
15837        obj.href = reader.get_attribute('href')
15838        value = reader.get_attribute('id')
15839        if value is not None:
15840            obj.id = value
15841
15842        # Discard the start tag:
15843        empty = reader.empty_element()
15844        reader.read()
15845        if empty:
15846            return obj
15847
15848        # Process the inner elements:
15849        links = []
15850        while reader.forward():
15851            tag = reader.node_name()
15852            if tag == 'comment':
15853                obj.comment = Reader.read_string(reader)
15854            elif tag == 'content':
15855                obj.content = Reader.read_string(reader)
15856            elif tag == 'description':
15857                obj.description = Reader.read_string(reader)
15858            elif tag == 'name':
15859                obj.name = Reader.read_string(reader)
15860            elif tag == 'user':
15861                obj.user = UserReader.read_one(reader)
15862            else:
15863                reader.next_element()
15864        for link in links:
15865            SshPublicKeyReader._process_link(link, obj)
15866
15867        # Discard the end tag:
15868        reader.read()
15869
15870        return obj
15871
15872    @staticmethod
15873    def read_many(reader):
15874        # Do nothing if there aren't more tags:
15875        objs = List()
15876        if not reader.forward():
15877            return objs
15878
15879        # Process the attributes:
15880        objs.href = reader.get_attribute('href')
15881
15882        # Discard the start tag:
15883        empty = reader.empty_element()
15884        reader.read()
15885        if empty:
15886            return objs
15887
15888        # Process the inner elements:
15889        while reader.forward():
15890            objs.append(SshPublicKeyReader.read_one(reader))
15891
15892        # Discard the end tag:
15893        reader.read()
15894
15895        return objs
15896
15897
15898class SsoReader(Reader):
15899
15900    def __init__(self):
15901        super(SsoReader, self).__init__()
15902
15903    @staticmethod
15904    def read_one(reader):
15905        # Do nothing if there aren't more tags:
15906        if not reader.forward():
15907            return None
15908
15909        # Create the object:
15910        obj = types.Sso()
15911
15912        # Process the attributes:
15913        obj.href = reader.get_attribute('href')
15914
15915        # Discard the start tag:
15916        empty = reader.empty_element()
15917        reader.read()
15918        if empty:
15919            return obj
15920
15921        # Process the inner elements:
15922        links = []
15923        while reader.forward():
15924            tag = reader.node_name()
15925            if tag == 'methods':
15926                obj.methods = MethodReader.read_many(reader)
15927            else:
15928                reader.next_element()
15929        for link in links:
15930            SsoReader._process_link(link, obj)
15931
15932        # Discard the end tag:
15933        reader.read()
15934
15935        return obj
15936
15937    @staticmethod
15938    def read_many(reader):
15939        # Do nothing if there aren't more tags:
15940        objs = List()
15941        if not reader.forward():
15942            return objs
15943
15944        # Process the attributes:
15945        objs.href = reader.get_attribute('href')
15946
15947        # Discard the start tag:
15948        empty = reader.empty_element()
15949        reader.read()
15950        if empty:
15951            return objs
15952
15953        # Process the inner elements:
15954        while reader.forward():
15955            objs.append(SsoReader.read_one(reader))
15956
15957        # Discard the end tag:
15958        reader.read()
15959
15960        return objs
15961
15962
15963class StatisticReader(Reader):
15964
15965    def __init__(self):
15966        super(StatisticReader, self).__init__()
15967
15968    @staticmethod
15969    def read_one(reader):
15970        # Do nothing if there aren't more tags:
15971        if not reader.forward():
15972            return None
15973
15974        # Create the object:
15975        obj = types.Statistic()
15976
15977        # Process the attributes:
15978        obj.href = reader.get_attribute('href')
15979        value = reader.get_attribute('id')
15980        if value is not None:
15981            obj.id = value
15982
15983        # Discard the start tag:
15984        empty = reader.empty_element()
15985        reader.read()
15986        if empty:
15987            return obj
15988
15989        # Process the inner elements:
15990        links = []
15991        while reader.forward():
15992            tag = reader.node_name()
15993            if tag == 'brick':
15994                obj.brick = GlusterBrickReader.read_one(reader)
15995            elif tag == 'comment':
15996                obj.comment = Reader.read_string(reader)
15997            elif tag == 'description':
15998                obj.description = Reader.read_string(reader)
15999            elif tag == 'disk':
16000                obj.disk = DiskReader.read_one(reader)
16001            elif tag == 'gluster_volume':
16002                obj.gluster_volume = GlusterVolumeReader.read_one(reader)
16003            elif tag == 'host':
16004                obj.host = HostReader.read_one(reader)
16005            elif tag == 'host_nic':
16006                obj.host_nic = HostNicReader.read_one(reader)
16007            elif tag == 'host_numa_node':
16008                obj.host_numa_node = NumaNodeReader.read_one(reader)
16009            elif tag == 'kind':
16010                obj.kind = Reader.read_enum(types.StatisticKind, reader)
16011            elif tag == 'name':
16012                obj.name = Reader.read_string(reader)
16013            elif tag == 'nic':
16014                obj.nic = NicReader.read_one(reader)
16015            elif tag == 'step':
16016                obj.step = StepReader.read_one(reader)
16017            elif tag == 'type':
16018                obj.type = Reader.read_enum(types.ValueType, reader)
16019            elif tag == 'unit':
16020                obj.unit = Reader.read_enum(types.StatisticUnit, reader)
16021            elif tag == 'values':
16022                obj.values = ValueReader.read_many(reader)
16023            elif tag == 'vm':
16024                obj.vm = VmReader.read_one(reader)
16025            else:
16026                reader.next_element()
16027        for link in links:
16028            StatisticReader._process_link(link, obj)
16029
16030        # Discard the end tag:
16031        reader.read()
16032
16033        return obj
16034
16035    @staticmethod
16036    def read_many(reader):
16037        # Do nothing if there aren't more tags:
16038        objs = List()
16039        if not reader.forward():
16040            return objs
16041
16042        # Process the attributes:
16043        objs.href = reader.get_attribute('href')
16044
16045        # Discard the start tag:
16046        empty = reader.empty_element()
16047        reader.read()
16048        if empty:
16049            return objs
16050
16051        # Process the inner elements:
16052        while reader.forward():
16053            objs.append(StatisticReader.read_one(reader))
16054
16055        # Discard the end tag:
16056        reader.read()
16057
16058        return objs
16059
16060
16061class StepReader(Reader):
16062
16063    def __init__(self):
16064        super(StepReader, self).__init__()
16065
16066    @staticmethod
16067    def read_one(reader):
16068        # Do nothing if there aren't more tags:
16069        if not reader.forward():
16070            return None
16071
16072        # Create the object:
16073        obj = types.Step()
16074
16075        # Process the attributes:
16076        obj.href = reader.get_attribute('href')
16077        value = reader.get_attribute('id')
16078        if value is not None:
16079            obj.id = value
16080
16081        # Discard the start tag:
16082        empty = reader.empty_element()
16083        reader.read()
16084        if empty:
16085            return obj
16086
16087        # Process the inner elements:
16088        links = []
16089        while reader.forward():
16090            tag = reader.node_name()
16091            if tag == 'comment':
16092                obj.comment = Reader.read_string(reader)
16093            elif tag == 'description':
16094                obj.description = Reader.read_string(reader)
16095            elif tag == 'end_time':
16096                obj.end_time = Reader.read_date(reader)
16097            elif tag == 'execution_host':
16098                obj.execution_host = HostReader.read_one(reader)
16099            elif tag == 'external':
16100                obj.external = Reader.read_boolean(reader)
16101            elif tag == 'external_type':
16102                obj.external_type = Reader.read_enum(types.ExternalSystemType, reader)
16103            elif tag == 'job':
16104                obj.job = JobReader.read_one(reader)
16105            elif tag == 'name':
16106                obj.name = Reader.read_string(reader)
16107            elif tag == 'number':
16108                obj.number = Reader.read_integer(reader)
16109            elif tag == 'parent_step':
16110                obj.parent_step = StepReader.read_one(reader)
16111            elif tag == 'progress':
16112                obj.progress = Reader.read_integer(reader)
16113            elif tag == 'start_time':
16114                obj.start_time = Reader.read_date(reader)
16115            elif tag == 'statistics':
16116                obj.statistics = StatisticReader.read_many(reader)
16117            elif tag == 'status':
16118                obj.status = Reader.read_enum(types.StepStatus, reader)
16119            elif tag == 'type':
16120                obj.type = Reader.read_enum(types.StepEnum, reader)
16121            elif tag == 'link':
16122                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
16123                reader.next_element()
16124            else:
16125                reader.next_element()
16126        for link in links:
16127            StepReader._process_link(link, obj)
16128
16129        # Discard the end tag:
16130        reader.read()
16131
16132        return obj
16133
16134    @staticmethod
16135    def read_many(reader):
16136        # Do nothing if there aren't more tags:
16137        objs = List()
16138        if not reader.forward():
16139            return objs
16140
16141        # Process the attributes:
16142        objs.href = reader.get_attribute('href')
16143
16144        # Discard the start tag:
16145        empty = reader.empty_element()
16146        reader.read()
16147        if empty:
16148            return objs
16149
16150        # Process the inner elements:
16151        while reader.forward():
16152            objs.append(StepReader.read_one(reader))
16153
16154        # Discard the end tag:
16155        reader.read()
16156
16157        return objs
16158
16159    @staticmethod
16160    def _process_link(link, obj):
16161        # Process the attributes:
16162        rel = link[0]
16163        href = link[1]
16164        if href and rel:
16165            if rel == "statistics":
16166                if obj.statistics is not None:
16167                    obj.statistics.href = href
16168                else:
16169                    obj.statistics = List(href)
16170
16171
16172class StorageConnectionReader(Reader):
16173
16174    def __init__(self):
16175        super(StorageConnectionReader, self).__init__()
16176
16177    @staticmethod
16178    def read_one(reader):
16179        # Do nothing if there aren't more tags:
16180        if not reader.forward():
16181            return None
16182
16183        # Create the object:
16184        obj = types.StorageConnection()
16185
16186        # Process the attributes:
16187        obj.href = reader.get_attribute('href')
16188        value = reader.get_attribute('id')
16189        if value is not None:
16190            obj.id = value
16191
16192        # Discard the start tag:
16193        empty = reader.empty_element()
16194        reader.read()
16195        if empty:
16196            return obj
16197
16198        # Process the inner elements:
16199        links = []
16200        while reader.forward():
16201            tag = reader.node_name()
16202            if tag == 'address':
16203                obj.address = Reader.read_string(reader)
16204            elif tag == 'comment':
16205                obj.comment = Reader.read_string(reader)
16206            elif tag == 'description':
16207                obj.description = Reader.read_string(reader)
16208            elif tag == 'gluster_volume':
16209                obj.gluster_volume = GlusterVolumeReader.read_one(reader)
16210            elif tag == 'host':
16211                obj.host = HostReader.read_one(reader)
16212            elif tag == 'mount_options':
16213                obj.mount_options = Reader.read_string(reader)
16214            elif tag == 'name':
16215                obj.name = Reader.read_string(reader)
16216            elif tag == 'nfs_retrans':
16217                obj.nfs_retrans = Reader.read_integer(reader)
16218            elif tag == 'nfs_timeo':
16219                obj.nfs_timeo = Reader.read_integer(reader)
16220            elif tag == 'nfs_version':
16221                obj.nfs_version = Reader.read_enum(types.NfsVersion, reader)
16222            elif tag == 'password':
16223                obj.password = Reader.read_string(reader)
16224            elif tag == 'path':
16225                obj.path = Reader.read_string(reader)
16226            elif tag == 'port':
16227                obj.port = Reader.read_integer(reader)
16228            elif tag == 'portal':
16229                obj.portal = Reader.read_string(reader)
16230            elif tag == 'target':
16231                obj.target = Reader.read_string(reader)
16232            elif tag == 'type':
16233                obj.type = Reader.read_enum(types.StorageType, reader)
16234            elif tag == 'username':
16235                obj.username = Reader.read_string(reader)
16236            elif tag == 'vfs_type':
16237                obj.vfs_type = Reader.read_string(reader)
16238            else:
16239                reader.next_element()
16240        for link in links:
16241            StorageConnectionReader._process_link(link, obj)
16242
16243        # Discard the end tag:
16244        reader.read()
16245
16246        return obj
16247
16248    @staticmethod
16249    def read_many(reader):
16250        # Do nothing if there aren't more tags:
16251        objs = List()
16252        if not reader.forward():
16253            return objs
16254
16255        # Process the attributes:
16256        objs.href = reader.get_attribute('href')
16257
16258        # Discard the start tag:
16259        empty = reader.empty_element()
16260        reader.read()
16261        if empty:
16262            return objs
16263
16264        # Process the inner elements:
16265        while reader.forward():
16266            objs.append(StorageConnectionReader.read_one(reader))
16267
16268        # Discard the end tag:
16269        reader.read()
16270
16271        return objs
16272
16273
16274class StorageConnectionExtensionReader(Reader):
16275
16276    def __init__(self):
16277        super(StorageConnectionExtensionReader, self).__init__()
16278
16279    @staticmethod
16280    def read_one(reader):
16281        # Do nothing if there aren't more tags:
16282        if not reader.forward():
16283            return None
16284
16285        # Create the object:
16286        obj = types.StorageConnectionExtension()
16287
16288        # Process the attributes:
16289        obj.href = reader.get_attribute('href')
16290        value = reader.get_attribute('id')
16291        if value is not None:
16292            obj.id = value
16293
16294        # Discard the start tag:
16295        empty = reader.empty_element()
16296        reader.read()
16297        if empty:
16298            return obj
16299
16300        # Process the inner elements:
16301        links = []
16302        while reader.forward():
16303            tag = reader.node_name()
16304            if tag == 'comment':
16305                obj.comment = Reader.read_string(reader)
16306            elif tag == 'description':
16307                obj.description = Reader.read_string(reader)
16308            elif tag == 'host':
16309                obj.host = HostReader.read_one(reader)
16310            elif tag == 'name':
16311                obj.name = Reader.read_string(reader)
16312            elif tag == 'password':
16313                obj.password = Reader.read_string(reader)
16314            elif tag == 'target':
16315                obj.target = Reader.read_string(reader)
16316            elif tag == 'username':
16317                obj.username = Reader.read_string(reader)
16318            else:
16319                reader.next_element()
16320        for link in links:
16321            StorageConnectionExtensionReader._process_link(link, obj)
16322
16323        # Discard the end tag:
16324        reader.read()
16325
16326        return obj
16327
16328    @staticmethod
16329    def read_many(reader):
16330        # Do nothing if there aren't more tags:
16331        objs = List()
16332        if not reader.forward():
16333            return objs
16334
16335        # Process the attributes:
16336        objs.href = reader.get_attribute('href')
16337
16338        # Discard the start tag:
16339        empty = reader.empty_element()
16340        reader.read()
16341        if empty:
16342            return objs
16343
16344        # Process the inner elements:
16345        while reader.forward():
16346            objs.append(StorageConnectionExtensionReader.read_one(reader))
16347
16348        # Discard the end tag:
16349        reader.read()
16350
16351        return objs
16352
16353
16354class StorageDomainReader(Reader):
16355
16356    def __init__(self):
16357        super(StorageDomainReader, self).__init__()
16358
16359    @staticmethod
16360    def read_one(reader):
16361        # Do nothing if there aren't more tags:
16362        if not reader.forward():
16363            return None
16364
16365        # Create the object:
16366        obj = types.StorageDomain()
16367
16368        # Process the attributes:
16369        obj.href = reader.get_attribute('href')
16370        value = reader.get_attribute('id')
16371        if value is not None:
16372            obj.id = value
16373
16374        # Discard the start tag:
16375        empty = reader.empty_element()
16376        reader.read()
16377        if empty:
16378            return obj
16379
16380        # Process the inner elements:
16381        links = []
16382        while reader.forward():
16383            tag = reader.node_name()
16384            if tag == 'available':
16385                obj.available = Reader.read_integer(reader)
16386            elif tag == 'backup':
16387                obj.backup = Reader.read_boolean(reader)
16388            elif tag == 'block_size':
16389                obj.block_size = Reader.read_integer(reader)
16390            elif tag == 'comment':
16391                obj.comment = Reader.read_string(reader)
16392            elif tag == 'committed':
16393                obj.committed = Reader.read_integer(reader)
16394            elif tag == 'critical_space_action_blocker':
16395                obj.critical_space_action_blocker = Reader.read_integer(reader)
16396            elif tag == 'data_center':
16397                obj.data_center = DataCenterReader.read_one(reader)
16398            elif tag == 'data_centers':
16399                obj.data_centers = DataCenterReader.read_many(reader)
16400            elif tag == 'description':
16401                obj.description = Reader.read_string(reader)
16402            elif tag == 'discard_after_delete':
16403                obj.discard_after_delete = Reader.read_boolean(reader)
16404            elif tag == 'disk_profiles':
16405                obj.disk_profiles = DiskProfileReader.read_many(reader)
16406            elif tag == 'disk_snapshots':
16407                obj.disk_snapshots = DiskSnapshotReader.read_many(reader)
16408            elif tag == 'disks':
16409                obj.disks = DiskReader.read_many(reader)
16410            elif tag == 'external_status':
16411                obj.external_status = Reader.read_enum(types.ExternalStatus, reader)
16412            elif tag == 'files':
16413                obj.files = FileReader.read_many(reader)
16414            elif tag == 'host':
16415                obj.host = HostReader.read_one(reader)
16416            elif tag == 'images':
16417                obj.images = ImageReader.read_many(reader)
16418            elif tag == 'import':
16419                obj.import_ = Reader.read_boolean(reader)
16420            elif tag == 'master':
16421                obj.master = Reader.read_boolean(reader)
16422            elif tag == 'name':
16423                obj.name = Reader.read_string(reader)
16424            elif tag == 'permissions':
16425                obj.permissions = PermissionReader.read_many(reader)
16426            elif tag == 'status':
16427                obj.status = Reader.read_enum(types.StorageDomainStatus, reader)
16428            elif tag == 'storage':
16429                obj.storage = HostStorageReader.read_one(reader)
16430            elif tag == 'storage_connections':
16431                obj.storage_connections = StorageConnectionReader.read_many(reader)
16432            elif tag == 'storage_format':
16433                obj.storage_format = Reader.read_enum(types.StorageFormat, reader)
16434            elif tag == 'supports_discard':
16435                obj.supports_discard = Reader.read_boolean(reader)
16436            elif tag == 'supports_discard_zeroes_data':
16437                obj.supports_discard_zeroes_data = Reader.read_boolean(reader)
16438            elif tag == 'templates':
16439                obj.templates = TemplateReader.read_many(reader)
16440            elif tag == 'type':
16441                obj.type = Reader.read_enum(types.StorageDomainType, reader)
16442            elif tag == 'used':
16443                obj.used = Reader.read_integer(reader)
16444            elif tag == 'vms':
16445                obj.vms = VmReader.read_many(reader)
16446            elif tag == 'warning_low_space_indicator':
16447                obj.warning_low_space_indicator = Reader.read_integer(reader)
16448            elif tag == 'wipe_after_delete':
16449                obj.wipe_after_delete = Reader.read_boolean(reader)
16450            elif tag == 'link':
16451                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
16452                reader.next_element()
16453            else:
16454                reader.next_element()
16455        for link in links:
16456            StorageDomainReader._process_link(link, obj)
16457
16458        # Discard the end tag:
16459        reader.read()
16460
16461        return obj
16462
16463    @staticmethod
16464    def read_many(reader):
16465        # Do nothing if there aren't more tags:
16466        objs = List()
16467        if not reader.forward():
16468            return objs
16469
16470        # Process the attributes:
16471        objs.href = reader.get_attribute('href')
16472
16473        # Discard the start tag:
16474        empty = reader.empty_element()
16475        reader.read()
16476        if empty:
16477            return objs
16478
16479        # Process the inner elements:
16480        while reader.forward():
16481            objs.append(StorageDomainReader.read_one(reader))
16482
16483        # Discard the end tag:
16484        reader.read()
16485
16486        return objs
16487
16488    @staticmethod
16489    def _process_link(link, obj):
16490        # Process the attributes:
16491        rel = link[0]
16492        href = link[1]
16493        if href and rel:
16494            if rel == "datacenters":
16495                if obj.data_centers is not None:
16496                    obj.data_centers.href = href
16497                else:
16498                    obj.data_centers = List(href)
16499            elif rel == "diskprofiles":
16500                if obj.disk_profiles is not None:
16501                    obj.disk_profiles.href = href
16502                else:
16503                    obj.disk_profiles = List(href)
16504            elif rel == "disksnapshots":
16505                if obj.disk_snapshots is not None:
16506                    obj.disk_snapshots.href = href
16507                else:
16508                    obj.disk_snapshots = List(href)
16509            elif rel == "disks":
16510                if obj.disks is not None:
16511                    obj.disks.href = href
16512                else:
16513                    obj.disks = List(href)
16514            elif rel == "files":
16515                if obj.files is not None:
16516                    obj.files.href = href
16517                else:
16518                    obj.files = List(href)
16519            elif rel == "images":
16520                if obj.images is not None:
16521                    obj.images.href = href
16522                else:
16523                    obj.images = List(href)
16524            elif rel == "permissions":
16525                if obj.permissions is not None:
16526                    obj.permissions.href = href
16527                else:
16528                    obj.permissions = List(href)
16529            elif rel == "storageconnections":
16530                if obj.storage_connections is not None:
16531                    obj.storage_connections.href = href
16532                else:
16533                    obj.storage_connections = List(href)
16534            elif rel == "templates":
16535                if obj.templates is not None:
16536                    obj.templates.href = href
16537                else:
16538                    obj.templates = List(href)
16539            elif rel == "vms":
16540                if obj.vms is not None:
16541                    obj.vms.href = href
16542                else:
16543                    obj.vms = List(href)
16544
16545
16546class StorageDomainLeaseReader(Reader):
16547
16548    def __init__(self):
16549        super(StorageDomainLeaseReader, self).__init__()
16550
16551    @staticmethod
16552    def read_one(reader):
16553        # Do nothing if there aren't more tags:
16554        if not reader.forward():
16555            return None
16556
16557        # Create the object:
16558        obj = types.StorageDomainLease()
16559
16560        # Process the attributes:
16561        obj.href = reader.get_attribute('href')
16562
16563        # Discard the start tag:
16564        empty = reader.empty_element()
16565        reader.read()
16566        if empty:
16567            return obj
16568
16569        # Process the inner elements:
16570        links = []
16571        while reader.forward():
16572            tag = reader.node_name()
16573            if tag == 'storage_domain':
16574                obj.storage_domain = StorageDomainReader.read_one(reader)
16575            else:
16576                reader.next_element()
16577        for link in links:
16578            StorageDomainLeaseReader._process_link(link, obj)
16579
16580        # Discard the end tag:
16581        reader.read()
16582
16583        return obj
16584
16585    @staticmethod
16586    def read_many(reader):
16587        # Do nothing if there aren't more tags:
16588        objs = List()
16589        if not reader.forward():
16590            return objs
16591
16592        # Process the attributes:
16593        objs.href = reader.get_attribute('href')
16594
16595        # Discard the start tag:
16596        empty = reader.empty_element()
16597        reader.read()
16598        if empty:
16599            return objs
16600
16601        # Process the inner elements:
16602        while reader.forward():
16603            objs.append(StorageDomainLeaseReader.read_one(reader))
16604
16605        # Discard the end tag:
16606        reader.read()
16607
16608        return objs
16609
16610
16611class SystemOptionReader(Reader):
16612
16613    def __init__(self):
16614        super(SystemOptionReader, self).__init__()
16615
16616    @staticmethod
16617    def read_one(reader):
16618        # Do nothing if there aren't more tags:
16619        if not reader.forward():
16620            return None
16621
16622        # Create the object:
16623        obj = types.SystemOption()
16624
16625        # Process the attributes:
16626        obj.href = reader.get_attribute('href')
16627        value = reader.get_attribute('id')
16628        if value is not None:
16629            obj.id = value
16630
16631        # Discard the start tag:
16632        empty = reader.empty_element()
16633        reader.read()
16634        if empty:
16635            return obj
16636
16637        # Process the inner elements:
16638        links = []
16639        while reader.forward():
16640            tag = reader.node_name()
16641            if tag == 'comment':
16642                obj.comment = Reader.read_string(reader)
16643            elif tag == 'description':
16644                obj.description = Reader.read_string(reader)
16645            elif tag == 'name':
16646                obj.name = Reader.read_string(reader)
16647            elif tag == 'values':
16648                obj.values = SystemOptionValueReader.read_many(reader)
16649            else:
16650                reader.next_element()
16651        for link in links:
16652            SystemOptionReader._process_link(link, obj)
16653
16654        # Discard the end tag:
16655        reader.read()
16656
16657        return obj
16658
16659    @staticmethod
16660    def read_many(reader):
16661        # Do nothing if there aren't more tags:
16662        objs = List()
16663        if not reader.forward():
16664            return objs
16665
16666        # Process the attributes:
16667        objs.href = reader.get_attribute('href')
16668
16669        # Discard the start tag:
16670        empty = reader.empty_element()
16671        reader.read()
16672        if empty:
16673            return objs
16674
16675        # Process the inner elements:
16676        while reader.forward():
16677            objs.append(SystemOptionReader.read_one(reader))
16678
16679        # Discard the end tag:
16680        reader.read()
16681
16682        return objs
16683
16684
16685class SystemOptionValueReader(Reader):
16686
16687    def __init__(self):
16688        super(SystemOptionValueReader, self).__init__()
16689
16690    @staticmethod
16691    def read_one(reader):
16692        # Do nothing if there aren't more tags:
16693        if not reader.forward():
16694            return None
16695
16696        # Create the object:
16697        obj = types.SystemOptionValue()
16698
16699        # Process the attributes:
16700        obj.href = reader.get_attribute('href')
16701
16702        # Discard the start tag:
16703        empty = reader.empty_element()
16704        reader.read()
16705        if empty:
16706            return obj
16707
16708        # Process the inner elements:
16709        links = []
16710        while reader.forward():
16711            tag = reader.node_name()
16712            if tag == 'value':
16713                obj.value = Reader.read_string(reader)
16714            elif tag == 'version':
16715                obj.version = Reader.read_string(reader)
16716            else:
16717                reader.next_element()
16718        for link in links:
16719            SystemOptionValueReader._process_link(link, obj)
16720
16721        # Discard the end tag:
16722        reader.read()
16723
16724        return obj
16725
16726    @staticmethod
16727    def read_many(reader):
16728        # Do nothing if there aren't more tags:
16729        objs = List()
16730        if not reader.forward():
16731            return objs
16732
16733        # Process the attributes:
16734        objs.href = reader.get_attribute('href')
16735
16736        # Discard the start tag:
16737        empty = reader.empty_element()
16738        reader.read()
16739        if empty:
16740            return objs
16741
16742        # Process the inner elements:
16743        while reader.forward():
16744            objs.append(SystemOptionValueReader.read_one(reader))
16745
16746        # Discard the end tag:
16747        reader.read()
16748
16749        return objs
16750
16751
16752class TagReader(Reader):
16753
16754    def __init__(self):
16755        super(TagReader, self).__init__()
16756
16757    @staticmethod
16758    def read_one(reader):
16759        # Do nothing if there aren't more tags:
16760        if not reader.forward():
16761            return None
16762
16763        # Create the object:
16764        obj = types.Tag()
16765
16766        # Process the attributes:
16767        obj.href = reader.get_attribute('href')
16768        value = reader.get_attribute('id')
16769        if value is not None:
16770            obj.id = value
16771
16772        # Discard the start tag:
16773        empty = reader.empty_element()
16774        reader.read()
16775        if empty:
16776            return obj
16777
16778        # Process the inner elements:
16779        links = []
16780        while reader.forward():
16781            tag = reader.node_name()
16782            if tag == 'comment':
16783                obj.comment = Reader.read_string(reader)
16784            elif tag == 'description':
16785                obj.description = Reader.read_string(reader)
16786            elif tag == 'group':
16787                obj.group = GroupReader.read_one(reader)
16788            elif tag == 'host':
16789                obj.host = HostReader.read_one(reader)
16790            elif tag == 'name':
16791                obj.name = Reader.read_string(reader)
16792            elif tag == 'parent':
16793                obj.parent = TagReader.read_one(reader)
16794            elif tag == 'template':
16795                obj.template = TemplateReader.read_one(reader)
16796            elif tag == 'user':
16797                obj.user = UserReader.read_one(reader)
16798            elif tag == 'vm':
16799                obj.vm = VmReader.read_one(reader)
16800            else:
16801                reader.next_element()
16802        for link in links:
16803            TagReader._process_link(link, obj)
16804
16805        # Discard the end tag:
16806        reader.read()
16807
16808        return obj
16809
16810    @staticmethod
16811    def read_many(reader):
16812        # Do nothing if there aren't more tags:
16813        objs = List()
16814        if not reader.forward():
16815            return objs
16816
16817        # Process the attributes:
16818        objs.href = reader.get_attribute('href')
16819
16820        # Discard the start tag:
16821        empty = reader.empty_element()
16822        reader.read()
16823        if empty:
16824            return objs
16825
16826        # Process the inner elements:
16827        while reader.forward():
16828            objs.append(TagReader.read_one(reader))
16829
16830        # Discard the end tag:
16831        reader.read()
16832
16833        return objs
16834
16835
16836class TemplateReader(Reader):
16837
16838    def __init__(self):
16839        super(TemplateReader, self).__init__()
16840
16841    @staticmethod
16842    def read_one(reader):
16843        # Do nothing if there aren't more tags:
16844        if not reader.forward():
16845            return None
16846
16847        # Create the object:
16848        obj = types.Template()
16849
16850        # Process the attributes:
16851        obj.href = reader.get_attribute('href')
16852        value = reader.get_attribute('id')
16853        if value is not None:
16854            obj.id = value
16855
16856        # Discard the start tag:
16857        empty = reader.empty_element()
16858        reader.read()
16859        if empty:
16860            return obj
16861
16862        # Process the inner elements:
16863        links = []
16864        while reader.forward():
16865            tag = reader.node_name()
16866            if tag == 'auto_pinning_policy':
16867                obj.auto_pinning_policy = Reader.read_enum(types.AutoPinningPolicy, reader)
16868            elif tag == 'bios':
16869                obj.bios = BiosReader.read_one(reader)
16870            elif tag == 'cdroms':
16871                obj.cdroms = CdromReader.read_many(reader)
16872            elif tag == 'cluster':
16873                obj.cluster = ClusterReader.read_one(reader)
16874            elif tag == 'comment':
16875                obj.comment = Reader.read_string(reader)
16876            elif tag == 'console':
16877                obj.console = ConsoleReader.read_one(reader)
16878            elif tag == 'cpu':
16879                obj.cpu = CpuReader.read_one(reader)
16880            elif tag == 'cpu_pinning_policy':
16881                obj.cpu_pinning_policy = Reader.read_enum(types.CpuPinningPolicy, reader)
16882            elif tag == 'cpu_profile':
16883                obj.cpu_profile = CpuProfileReader.read_one(reader)
16884            elif tag == 'cpu_shares':
16885                obj.cpu_shares = Reader.read_integer(reader)
16886            elif tag == 'creation_time':
16887                obj.creation_time = Reader.read_date(reader)
16888            elif tag == 'custom_compatibility_version':
16889                obj.custom_compatibility_version = VersionReader.read_one(reader)
16890            elif tag == 'custom_cpu_model':
16891                obj.custom_cpu_model = Reader.read_string(reader)
16892            elif tag == 'custom_emulated_machine':
16893                obj.custom_emulated_machine = Reader.read_string(reader)
16894            elif tag == 'custom_properties':
16895                obj.custom_properties = CustomPropertyReader.read_many(reader)
16896            elif tag == 'delete_protected':
16897                obj.delete_protected = Reader.read_boolean(reader)
16898            elif tag == 'description':
16899                obj.description = Reader.read_string(reader)
16900            elif tag == 'disk_attachments':
16901                obj.disk_attachments = DiskAttachmentReader.read_many(reader)
16902            elif tag == 'display':
16903                obj.display = DisplayReader.read_one(reader)
16904            elif tag == 'domain':
16905                obj.domain = DomainReader.read_one(reader)
16906            elif tag == 'graphics_consoles':
16907                obj.graphics_consoles = GraphicsConsoleReader.read_many(reader)
16908            elif tag == 'high_availability':
16909                obj.high_availability = HighAvailabilityReader.read_one(reader)
16910            elif tag == 'initialization':
16911                obj.initialization = InitializationReader.read_one(reader)
16912            elif tag == 'io':
16913                obj.io = IoReader.read_one(reader)
16914            elif tag == 'large_icon':
16915                obj.large_icon = IconReader.read_one(reader)
16916            elif tag == 'lease':
16917                obj.lease = StorageDomainLeaseReader.read_one(reader)
16918            elif tag == 'mediated_devices':
16919                obj.mediated_devices = VmMediatedDeviceReader.read_many(reader)
16920            elif tag == 'memory':
16921                obj.memory = Reader.read_integer(reader)
16922            elif tag == 'memory_policy':
16923                obj.memory_policy = MemoryPolicyReader.read_one(reader)
16924            elif tag == 'migration':
16925                obj.migration = MigrationOptionsReader.read_one(reader)
16926            elif tag == 'migration_downtime':
16927                obj.migration_downtime = Reader.read_integer(reader)
16928            elif tag == 'multi_queues_enabled':
16929                obj.multi_queues_enabled = Reader.read_boolean(reader)
16930            elif tag == 'name':
16931                obj.name = Reader.read_string(reader)
16932            elif tag == 'nics':
16933                obj.nics = NicReader.read_many(reader)
16934            elif tag == 'origin':
16935                obj.origin = Reader.read_string(reader)
16936            elif tag == 'os':
16937                obj.os = OperatingSystemReader.read_one(reader)
16938            elif tag == 'permissions':
16939                obj.permissions = PermissionReader.read_many(reader)
16940            elif tag == 'placement_policy':
16941                obj.placement_policy = VmPlacementPolicyReader.read_one(reader)
16942            elif tag == 'quota':
16943                obj.quota = QuotaReader.read_one(reader)
16944            elif tag == 'rng_device':
16945                obj.rng_device = RngDeviceReader.read_one(reader)
16946            elif tag == 'serial_number':
16947                obj.serial_number = SerialNumberReader.read_one(reader)
16948            elif tag == 'small_icon':
16949                obj.small_icon = IconReader.read_one(reader)
16950            elif tag == 'soundcard_enabled':
16951                obj.soundcard_enabled = Reader.read_boolean(reader)
16952            elif tag == 'sso':
16953                obj.sso = SsoReader.read_one(reader)
16954            elif tag == 'start_paused':
16955                obj.start_paused = Reader.read_boolean(reader)
16956            elif tag == 'stateless':
16957                obj.stateless = Reader.read_boolean(reader)
16958            elif tag == 'status':
16959                obj.status = Reader.read_enum(types.TemplateStatus, reader)
16960            elif tag == 'storage_domain':
16961                obj.storage_domain = StorageDomainReader.read_one(reader)
16962            elif tag == 'storage_error_resume_behaviour':
16963                obj.storage_error_resume_behaviour = Reader.read_enum(types.VmStorageErrorResumeBehaviour, reader)
16964            elif tag == 'tags':
16965                obj.tags = TagReader.read_many(reader)
16966            elif tag == 'time_zone':
16967                obj.time_zone = TimeZoneReader.read_one(reader)
16968            elif tag == 'tpm_enabled':
16969                obj.tpm_enabled = Reader.read_boolean(reader)
16970            elif tag == 'tunnel_migration':
16971                obj.tunnel_migration = Reader.read_boolean(reader)
16972            elif tag == 'type':
16973                obj.type = Reader.read_enum(types.VmType, reader)
16974            elif tag == 'usb':
16975                obj.usb = UsbReader.read_one(reader)
16976            elif tag == 'version':
16977                obj.version = TemplateVersionReader.read_one(reader)
16978            elif tag == 'virtio_scsi':
16979                obj.virtio_scsi = VirtioScsiReader.read_one(reader)
16980            elif tag == 'virtio_scsi_multi_queues':
16981                obj.virtio_scsi_multi_queues = Reader.read_integer(reader)
16982            elif tag == 'virtio_scsi_multi_queues_enabled':
16983                obj.virtio_scsi_multi_queues_enabled = Reader.read_boolean(reader)
16984            elif tag == 'vm':
16985                obj.vm = VmReader.read_one(reader)
16986            elif tag == 'watchdogs':
16987                obj.watchdogs = WatchdogReader.read_many(reader)
16988            elif tag == 'link':
16989                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
16990                reader.next_element()
16991            else:
16992                reader.next_element()
16993        for link in links:
16994            TemplateReader._process_link(link, obj)
16995
16996        # Discard the end tag:
16997        reader.read()
16998
16999        return obj
17000
17001    @staticmethod
17002    def read_many(reader):
17003        # Do nothing if there aren't more tags:
17004        objs = List()
17005        if not reader.forward():
17006            return objs
17007
17008        # Process the attributes:
17009        objs.href = reader.get_attribute('href')
17010
17011        # Discard the start tag:
17012        empty = reader.empty_element()
17013        reader.read()
17014        if empty:
17015            return objs
17016
17017        # Process the inner elements:
17018        while reader.forward():
17019            objs.append(TemplateReader.read_one(reader))
17020
17021        # Discard the end tag:
17022        reader.read()
17023
17024        return objs
17025
17026    @staticmethod
17027    def _process_link(link, obj):
17028        # Process the attributes:
17029        rel = link[0]
17030        href = link[1]
17031        if href and rel:
17032            if rel == "cdroms":
17033                if obj.cdroms is not None:
17034                    obj.cdroms.href = href
17035                else:
17036                    obj.cdroms = List(href)
17037            elif rel == "diskattachments":
17038                if obj.disk_attachments is not None:
17039                    obj.disk_attachments.href = href
17040                else:
17041                    obj.disk_attachments = List(href)
17042            elif rel == "graphicsconsoles":
17043                if obj.graphics_consoles is not None:
17044                    obj.graphics_consoles.href = href
17045                else:
17046                    obj.graphics_consoles = List(href)
17047            elif rel == "mediateddevices":
17048                if obj.mediated_devices is not None:
17049                    obj.mediated_devices.href = href
17050                else:
17051                    obj.mediated_devices = List(href)
17052            elif rel == "nics":
17053                if obj.nics is not None:
17054                    obj.nics.href = href
17055                else:
17056                    obj.nics = List(href)
17057            elif rel == "permissions":
17058                if obj.permissions is not None:
17059                    obj.permissions.href = href
17060                else:
17061                    obj.permissions = List(href)
17062            elif rel == "tags":
17063                if obj.tags is not None:
17064                    obj.tags.href = href
17065                else:
17066                    obj.tags = List(href)
17067            elif rel == "watchdogs":
17068                if obj.watchdogs is not None:
17069                    obj.watchdogs.href = href
17070                else:
17071                    obj.watchdogs = List(href)
17072
17073
17074class TemplateVersionReader(Reader):
17075
17076    def __init__(self):
17077        super(TemplateVersionReader, self).__init__()
17078
17079    @staticmethod
17080    def read_one(reader):
17081        # Do nothing if there aren't more tags:
17082        if not reader.forward():
17083            return None
17084
17085        # Create the object:
17086        obj = types.TemplateVersion()
17087
17088        # Process the attributes:
17089        obj.href = reader.get_attribute('href')
17090
17091        # Discard the start tag:
17092        empty = reader.empty_element()
17093        reader.read()
17094        if empty:
17095            return obj
17096
17097        # Process the inner elements:
17098        links = []
17099        while reader.forward():
17100            tag = reader.node_name()
17101            if tag == 'base_template':
17102                obj.base_template = TemplateReader.read_one(reader)
17103            elif tag == 'version_name':
17104                obj.version_name = Reader.read_string(reader)
17105            elif tag == 'version_number':
17106                obj.version_number = Reader.read_integer(reader)
17107            else:
17108                reader.next_element()
17109        for link in links:
17110            TemplateVersionReader._process_link(link, obj)
17111
17112        # Discard the end tag:
17113        reader.read()
17114
17115        return obj
17116
17117    @staticmethod
17118    def read_many(reader):
17119        # Do nothing if there aren't more tags:
17120        objs = List()
17121        if not reader.forward():
17122            return objs
17123
17124        # Process the attributes:
17125        objs.href = reader.get_attribute('href')
17126
17127        # Discard the start tag:
17128        empty = reader.empty_element()
17129        reader.read()
17130        if empty:
17131            return objs
17132
17133        # Process the inner elements:
17134        while reader.forward():
17135            objs.append(TemplateVersionReader.read_one(reader))
17136
17137        # Discard the end tag:
17138        reader.read()
17139
17140        return objs
17141
17142
17143class TicketReader(Reader):
17144
17145    def __init__(self):
17146        super(TicketReader, self).__init__()
17147
17148    @staticmethod
17149    def read_one(reader):
17150        # Do nothing if there aren't more tags:
17151        if not reader.forward():
17152            return None
17153
17154        # Create the object:
17155        obj = types.Ticket()
17156
17157        # Process the attributes:
17158        obj.href = reader.get_attribute('href')
17159
17160        # Discard the start tag:
17161        empty = reader.empty_element()
17162        reader.read()
17163        if empty:
17164            return obj
17165
17166        # Process the inner elements:
17167        links = []
17168        while reader.forward():
17169            tag = reader.node_name()
17170            if tag == 'expiry':
17171                obj.expiry = Reader.read_integer(reader)
17172            elif tag == 'value':
17173                obj.value = Reader.read_string(reader)
17174            else:
17175                reader.next_element()
17176        for link in links:
17177            TicketReader._process_link(link, obj)
17178
17179        # Discard the end tag:
17180        reader.read()
17181
17182        return obj
17183
17184    @staticmethod
17185    def read_many(reader):
17186        # Do nothing if there aren't more tags:
17187        objs = List()
17188        if not reader.forward():
17189            return objs
17190
17191        # Process the attributes:
17192        objs.href = reader.get_attribute('href')
17193
17194        # Discard the start tag:
17195        empty = reader.empty_element()
17196        reader.read()
17197        if empty:
17198            return objs
17199
17200        # Process the inner elements:
17201        while reader.forward():
17202            objs.append(TicketReader.read_one(reader))
17203
17204        # Discard the end tag:
17205        reader.read()
17206
17207        return objs
17208
17209
17210class TimeZoneReader(Reader):
17211
17212    def __init__(self):
17213        super(TimeZoneReader, self).__init__()
17214
17215    @staticmethod
17216    def read_one(reader):
17217        # Do nothing if there aren't more tags:
17218        if not reader.forward():
17219            return None
17220
17221        # Create the object:
17222        obj = types.TimeZone()
17223
17224        # Process the attributes:
17225        obj.href = reader.get_attribute('href')
17226
17227        # Discard the start tag:
17228        empty = reader.empty_element()
17229        reader.read()
17230        if empty:
17231            return obj
17232
17233        # Process the inner elements:
17234        links = []
17235        while reader.forward():
17236            tag = reader.node_name()
17237            if tag == 'name':
17238                obj.name = Reader.read_string(reader)
17239            elif tag == 'utc_offset':
17240                obj.utc_offset = Reader.read_string(reader)
17241            else:
17242                reader.next_element()
17243        for link in links:
17244            TimeZoneReader._process_link(link, obj)
17245
17246        # Discard the end tag:
17247        reader.read()
17248
17249        return obj
17250
17251    @staticmethod
17252    def read_many(reader):
17253        # Do nothing if there aren't more tags:
17254        objs = List()
17255        if not reader.forward():
17256            return objs
17257
17258        # Process the attributes:
17259        objs.href = reader.get_attribute('href')
17260
17261        # Discard the start tag:
17262        empty = reader.empty_element()
17263        reader.read()
17264        if empty:
17265            return objs
17266
17267        # Process the inner elements:
17268        while reader.forward():
17269            objs.append(TimeZoneReader.read_one(reader))
17270
17271        # Discard the end tag:
17272        reader.read()
17273
17274        return objs
17275
17276
17277class TransparentHugePagesReader(Reader):
17278
17279    def __init__(self):
17280        super(TransparentHugePagesReader, self).__init__()
17281
17282    @staticmethod
17283    def read_one(reader):
17284        # Do nothing if there aren't more tags:
17285        if not reader.forward():
17286            return None
17287
17288        # Create the object:
17289        obj = types.TransparentHugePages()
17290
17291        # Process the attributes:
17292        obj.href = reader.get_attribute('href')
17293
17294        # Discard the start tag:
17295        empty = reader.empty_element()
17296        reader.read()
17297        if empty:
17298            return obj
17299
17300        # Process the inner elements:
17301        links = []
17302        while reader.forward():
17303            tag = reader.node_name()
17304            if tag == 'enabled':
17305                obj.enabled = Reader.read_boolean(reader)
17306            else:
17307                reader.next_element()
17308        for link in links:
17309            TransparentHugePagesReader._process_link(link, obj)
17310
17311        # Discard the end tag:
17312        reader.read()
17313
17314        return obj
17315
17316    @staticmethod
17317    def read_many(reader):
17318        # Do nothing if there aren't more tags:
17319        objs = List()
17320        if not reader.forward():
17321            return objs
17322
17323        # Process the attributes:
17324        objs.href = reader.get_attribute('href')
17325
17326        # Discard the start tag:
17327        empty = reader.empty_element()
17328        reader.read()
17329        if empty:
17330            return objs
17331
17332        # Process the inner elements:
17333        while reader.forward():
17334            objs.append(TransparentHugePagesReader.read_one(reader))
17335
17336        # Discard the end tag:
17337        reader.read()
17338
17339        return objs
17340
17341
17342class UnmanagedNetworkReader(Reader):
17343
17344    def __init__(self):
17345        super(UnmanagedNetworkReader, self).__init__()
17346
17347    @staticmethod
17348    def read_one(reader):
17349        # Do nothing if there aren't more tags:
17350        if not reader.forward():
17351            return None
17352
17353        # Create the object:
17354        obj = types.UnmanagedNetwork()
17355
17356        # Process the attributes:
17357        obj.href = reader.get_attribute('href')
17358        value = reader.get_attribute('id')
17359        if value is not None:
17360            obj.id = value
17361
17362        # Discard the start tag:
17363        empty = reader.empty_element()
17364        reader.read()
17365        if empty:
17366            return obj
17367
17368        # Process the inner elements:
17369        links = []
17370        while reader.forward():
17371            tag = reader.node_name()
17372            if tag == 'comment':
17373                obj.comment = Reader.read_string(reader)
17374            elif tag == 'description':
17375                obj.description = Reader.read_string(reader)
17376            elif tag == 'host':
17377                obj.host = HostReader.read_one(reader)
17378            elif tag == 'host_nic':
17379                obj.host_nic = HostNicReader.read_one(reader)
17380            elif tag == 'name':
17381                obj.name = Reader.read_string(reader)
17382            else:
17383                reader.next_element()
17384        for link in links:
17385            UnmanagedNetworkReader._process_link(link, obj)
17386
17387        # Discard the end tag:
17388        reader.read()
17389
17390        return obj
17391
17392    @staticmethod
17393    def read_many(reader):
17394        # Do nothing if there aren't more tags:
17395        objs = List()
17396        if not reader.forward():
17397            return objs
17398
17399        # Process the attributes:
17400        objs.href = reader.get_attribute('href')
17401
17402        # Discard the start tag:
17403        empty = reader.empty_element()
17404        reader.read()
17405        if empty:
17406            return objs
17407
17408        # Process the inner elements:
17409        while reader.forward():
17410            objs.append(UnmanagedNetworkReader.read_one(reader))
17411
17412        # Discard the end tag:
17413        reader.read()
17414
17415        return objs
17416
17417
17418class UsbReader(Reader):
17419
17420    def __init__(self):
17421        super(UsbReader, self).__init__()
17422
17423    @staticmethod
17424    def read_one(reader):
17425        # Do nothing if there aren't more tags:
17426        if not reader.forward():
17427            return None
17428
17429        # Create the object:
17430        obj = types.Usb()
17431
17432        # Process the attributes:
17433        obj.href = reader.get_attribute('href')
17434
17435        # Discard the start tag:
17436        empty = reader.empty_element()
17437        reader.read()
17438        if empty:
17439            return obj
17440
17441        # Process the inner elements:
17442        links = []
17443        while reader.forward():
17444            tag = reader.node_name()
17445            if tag == 'enabled':
17446                obj.enabled = Reader.read_boolean(reader)
17447            elif tag == 'type':
17448                obj.type = Reader.read_enum(types.UsbType, reader)
17449            else:
17450                reader.next_element()
17451        for link in links:
17452            UsbReader._process_link(link, obj)
17453
17454        # Discard the end tag:
17455        reader.read()
17456
17457        return obj
17458
17459    @staticmethod
17460    def read_many(reader):
17461        # Do nothing if there aren't more tags:
17462        objs = List()
17463        if not reader.forward():
17464            return objs
17465
17466        # Process the attributes:
17467        objs.href = reader.get_attribute('href')
17468
17469        # Discard the start tag:
17470        empty = reader.empty_element()
17471        reader.read()
17472        if empty:
17473            return objs
17474
17475        # Process the inner elements:
17476        while reader.forward():
17477            objs.append(UsbReader.read_one(reader))
17478
17479        # Discard the end tag:
17480        reader.read()
17481
17482        return objs
17483
17484
17485class UserReader(Reader):
17486
17487    def __init__(self):
17488        super(UserReader, self).__init__()
17489
17490    @staticmethod
17491    def read_one(reader):
17492        # Do nothing if there aren't more tags:
17493        if not reader.forward():
17494            return None
17495
17496        # Create the object:
17497        obj = types.User()
17498
17499        # Process the attributes:
17500        obj.href = reader.get_attribute('href')
17501        value = reader.get_attribute('id')
17502        if value is not None:
17503            obj.id = value
17504
17505        # Discard the start tag:
17506        empty = reader.empty_element()
17507        reader.read()
17508        if empty:
17509            return obj
17510
17511        # Process the inner elements:
17512        links = []
17513        while reader.forward():
17514            tag = reader.node_name()
17515            if tag == 'comment':
17516                obj.comment = Reader.read_string(reader)
17517            elif tag == 'department':
17518                obj.department = Reader.read_string(reader)
17519            elif tag == 'description':
17520                obj.description = Reader.read_string(reader)
17521            elif tag == 'domain':
17522                obj.domain = DomainReader.read_one(reader)
17523            elif tag == 'domain_entry_id':
17524                obj.domain_entry_id = Reader.read_string(reader)
17525            elif tag == 'email':
17526                obj.email = Reader.read_string(reader)
17527            elif tag == 'groups':
17528                obj.groups = GroupReader.read_many(reader)
17529            elif tag == 'last_name':
17530                obj.last_name = Reader.read_string(reader)
17531            elif tag == 'logged_in':
17532                obj.logged_in = Reader.read_boolean(reader)
17533            elif tag == 'name':
17534                obj.name = Reader.read_string(reader)
17535            elif tag == 'namespace':
17536                obj.namespace = Reader.read_string(reader)
17537            elif tag == 'options':
17538                obj.options = UserOptionReader.read_many(reader)
17539            elif tag == 'password':
17540                obj.password = Reader.read_string(reader)
17541            elif tag == 'permissions':
17542                obj.permissions = PermissionReader.read_many(reader)
17543            elif tag == 'principal':
17544                obj.principal = Reader.read_string(reader)
17545            elif tag == 'roles':
17546                obj.roles = RoleReader.read_many(reader)
17547            elif tag == 'ssh_public_keys':
17548                obj.ssh_public_keys = SshPublicKeyReader.read_many(reader)
17549            elif tag == 'tags':
17550                obj.tags = TagReader.read_many(reader)
17551            elif tag == 'user_name':
17552                obj.user_name = Reader.read_string(reader)
17553            elif tag == 'user_options':
17554                obj.user_options = PropertyReader.read_many(reader)
17555            elif tag == 'link':
17556                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
17557                reader.next_element()
17558            else:
17559                reader.next_element()
17560        for link in links:
17561            UserReader._process_link(link, obj)
17562
17563        # Discard the end tag:
17564        reader.read()
17565
17566        return obj
17567
17568    @staticmethod
17569    def read_many(reader):
17570        # Do nothing if there aren't more tags:
17571        objs = List()
17572        if not reader.forward():
17573            return objs
17574
17575        # Process the attributes:
17576        objs.href = reader.get_attribute('href')
17577
17578        # Discard the start tag:
17579        empty = reader.empty_element()
17580        reader.read()
17581        if empty:
17582            return objs
17583
17584        # Process the inner elements:
17585        while reader.forward():
17586            objs.append(UserReader.read_one(reader))
17587
17588        # Discard the end tag:
17589        reader.read()
17590
17591        return objs
17592
17593    @staticmethod
17594    def _process_link(link, obj):
17595        # Process the attributes:
17596        rel = link[0]
17597        href = link[1]
17598        if href and rel:
17599            if rel == "groups":
17600                if obj.groups is not None:
17601                    obj.groups.href = href
17602                else:
17603                    obj.groups = List(href)
17604            elif rel == "options":
17605                if obj.options is not None:
17606                    obj.options.href = href
17607                else:
17608                    obj.options = List(href)
17609            elif rel == "permissions":
17610                if obj.permissions is not None:
17611                    obj.permissions.href = href
17612                else:
17613                    obj.permissions = List(href)
17614            elif rel == "roles":
17615                if obj.roles is not None:
17616                    obj.roles.href = href
17617                else:
17618                    obj.roles = List(href)
17619            elif rel == "sshpublickeys":
17620                if obj.ssh_public_keys is not None:
17621                    obj.ssh_public_keys.href = href
17622                else:
17623                    obj.ssh_public_keys = List(href)
17624            elif rel == "tags":
17625                if obj.tags is not None:
17626                    obj.tags.href = href
17627                else:
17628                    obj.tags = List(href)
17629
17630
17631class UserOptionReader(Reader):
17632
17633    def __init__(self):
17634        super(UserOptionReader, self).__init__()
17635
17636    @staticmethod
17637    def read_one(reader):
17638        # Do nothing if there aren't more tags:
17639        if not reader.forward():
17640            return None
17641
17642        # Create the object:
17643        obj = types.UserOption()
17644
17645        # Process the attributes:
17646        obj.href = reader.get_attribute('href')
17647        value = reader.get_attribute('id')
17648        if value is not None:
17649            obj.id = value
17650
17651        # Discard the start tag:
17652        empty = reader.empty_element()
17653        reader.read()
17654        if empty:
17655            return obj
17656
17657        # Process the inner elements:
17658        links = []
17659        while reader.forward():
17660            tag = reader.node_name()
17661            if tag == 'comment':
17662                obj.comment = Reader.read_string(reader)
17663            elif tag == 'content':
17664                obj.content = Reader.read_string(reader)
17665            elif tag == 'description':
17666                obj.description = Reader.read_string(reader)
17667            elif tag == 'name':
17668                obj.name = Reader.read_string(reader)
17669            elif tag == 'user':
17670                obj.user = UserReader.read_one(reader)
17671            else:
17672                reader.next_element()
17673        for link in links:
17674            UserOptionReader._process_link(link, obj)
17675
17676        # Discard the end tag:
17677        reader.read()
17678
17679        return obj
17680
17681    @staticmethod
17682    def read_many(reader):
17683        # Do nothing if there aren't more tags:
17684        objs = List()
17685        if not reader.forward():
17686            return objs
17687
17688        # Process the attributes:
17689        objs.href = reader.get_attribute('href')
17690
17691        # Discard the start tag:
17692        empty = reader.empty_element()
17693        reader.read()
17694        if empty:
17695            return objs
17696
17697        # Process the inner elements:
17698        while reader.forward():
17699            objs.append(UserOptionReader.read_one(reader))
17700
17701        # Discard the end tag:
17702        reader.read()
17703
17704        return objs
17705
17706
17707class ValueReader(Reader):
17708
17709    def __init__(self):
17710        super(ValueReader, self).__init__()
17711
17712    @staticmethod
17713    def read_one(reader):
17714        # Do nothing if there aren't more tags:
17715        if not reader.forward():
17716            return None
17717
17718        # Create the object:
17719        obj = types.Value()
17720
17721        # Process the attributes:
17722        obj.href = reader.get_attribute('href')
17723
17724        # Discard the start tag:
17725        empty = reader.empty_element()
17726        reader.read()
17727        if empty:
17728            return obj
17729
17730        # Process the inner elements:
17731        links = []
17732        while reader.forward():
17733            tag = reader.node_name()
17734            if tag == 'datum':
17735                obj.datum = Reader.read_decimal(reader)
17736            elif tag == 'detail':
17737                obj.detail = Reader.read_string(reader)
17738            else:
17739                reader.next_element()
17740        for link in links:
17741            ValueReader._process_link(link, obj)
17742
17743        # Discard the end tag:
17744        reader.read()
17745
17746        return obj
17747
17748    @staticmethod
17749    def read_many(reader):
17750        # Do nothing if there aren't more tags:
17751        objs = List()
17752        if not reader.forward():
17753            return objs
17754
17755        # Process the attributes:
17756        objs.href = reader.get_attribute('href')
17757
17758        # Discard the start tag:
17759        empty = reader.empty_element()
17760        reader.read()
17761        if empty:
17762            return objs
17763
17764        # Process the inner elements:
17765        while reader.forward():
17766            objs.append(ValueReader.read_one(reader))
17767
17768        # Discard the end tag:
17769        reader.read()
17770
17771        return objs
17772
17773
17774class VcpuPinReader(Reader):
17775
17776    def __init__(self):
17777        super(VcpuPinReader, self).__init__()
17778
17779    @staticmethod
17780    def read_one(reader):
17781        # Do nothing if there aren't more tags:
17782        if not reader.forward():
17783            return None
17784
17785        # Create the object:
17786        obj = types.VcpuPin()
17787
17788        # Process the attributes:
17789        obj.href = reader.get_attribute('href')
17790
17791        # Discard the start tag:
17792        empty = reader.empty_element()
17793        reader.read()
17794        if empty:
17795            return obj
17796
17797        # Process the inner elements:
17798        links = []
17799        while reader.forward():
17800            tag = reader.node_name()
17801            if tag == 'cpu_set':
17802                obj.cpu_set = Reader.read_string(reader)
17803            elif tag == 'vcpu':
17804                obj.vcpu = Reader.read_integer(reader)
17805            else:
17806                reader.next_element()
17807        for link in links:
17808            VcpuPinReader._process_link(link, obj)
17809
17810        # Discard the end tag:
17811        reader.read()
17812
17813        return obj
17814
17815    @staticmethod
17816    def read_many(reader):
17817        # Do nothing if there aren't more tags:
17818        objs = List()
17819        if not reader.forward():
17820            return objs
17821
17822        # Process the attributes:
17823        objs.href = reader.get_attribute('href')
17824
17825        # Discard the start tag:
17826        empty = reader.empty_element()
17827        reader.read()
17828        if empty:
17829            return objs
17830
17831        # Process the inner elements:
17832        while reader.forward():
17833            objs.append(VcpuPinReader.read_one(reader))
17834
17835        # Discard the end tag:
17836        reader.read()
17837
17838        return objs
17839
17840
17841class VendorReader(Reader):
17842
17843    def __init__(self):
17844        super(VendorReader, self).__init__()
17845
17846    @staticmethod
17847    def read_one(reader):
17848        # Do nothing if there aren't more tags:
17849        if not reader.forward():
17850            return None
17851
17852        # Create the object:
17853        obj = types.Vendor()
17854
17855        # Process the attributes:
17856        obj.href = reader.get_attribute('href')
17857        value = reader.get_attribute('id')
17858        if value is not None:
17859            obj.id = value
17860
17861        # Discard the start tag:
17862        empty = reader.empty_element()
17863        reader.read()
17864        if empty:
17865            return obj
17866
17867        # Process the inner elements:
17868        links = []
17869        while reader.forward():
17870            tag = reader.node_name()
17871            if tag == 'comment':
17872                obj.comment = Reader.read_string(reader)
17873            elif tag == 'description':
17874                obj.description = Reader.read_string(reader)
17875            elif tag == 'name':
17876                obj.name = Reader.read_string(reader)
17877            else:
17878                reader.next_element()
17879        for link in links:
17880            VendorReader._process_link(link, obj)
17881
17882        # Discard the end tag:
17883        reader.read()
17884
17885        return obj
17886
17887    @staticmethod
17888    def read_many(reader):
17889        # Do nothing if there aren't more tags:
17890        objs = List()
17891        if not reader.forward():
17892            return objs
17893
17894        # Process the attributes:
17895        objs.href = reader.get_attribute('href')
17896
17897        # Discard the start tag:
17898        empty = reader.empty_element()
17899        reader.read()
17900        if empty:
17901            return objs
17902
17903        # Process the inner elements:
17904        while reader.forward():
17905            objs.append(VendorReader.read_one(reader))
17906
17907        # Discard the end tag:
17908        reader.read()
17909
17910        return objs
17911
17912
17913class VersionReader(Reader):
17914
17915    def __init__(self):
17916        super(VersionReader, self).__init__()
17917
17918    @staticmethod
17919    def read_one(reader):
17920        # Do nothing if there aren't more tags:
17921        if not reader.forward():
17922            return None
17923
17924        # Create the object:
17925        obj = types.Version()
17926
17927        # Process the attributes:
17928        obj.href = reader.get_attribute('href')
17929        value = reader.get_attribute('id')
17930        if value is not None:
17931            obj.id = value
17932
17933        # Discard the start tag:
17934        empty = reader.empty_element()
17935        reader.read()
17936        if empty:
17937            return obj
17938
17939        # Process the inner elements:
17940        links = []
17941        while reader.forward():
17942            tag = reader.node_name()
17943            if tag == 'build':
17944                obj.build = Reader.read_integer(reader)
17945            elif tag == 'comment':
17946                obj.comment = Reader.read_string(reader)
17947            elif tag == 'description':
17948                obj.description = Reader.read_string(reader)
17949            elif tag == 'full_version':
17950                obj.full_version = Reader.read_string(reader)
17951            elif tag == 'major':
17952                obj.major = Reader.read_integer(reader)
17953            elif tag == 'minor':
17954                obj.minor = Reader.read_integer(reader)
17955            elif tag == 'name':
17956                obj.name = Reader.read_string(reader)
17957            elif tag == 'revision':
17958                obj.revision = Reader.read_integer(reader)
17959            else:
17960                reader.next_element()
17961        for link in links:
17962            VersionReader._process_link(link, obj)
17963
17964        # Discard the end tag:
17965        reader.read()
17966
17967        return obj
17968
17969    @staticmethod
17970    def read_many(reader):
17971        # Do nothing if there aren't more tags:
17972        objs = List()
17973        if not reader.forward():
17974            return objs
17975
17976        # Process the attributes:
17977        objs.href = reader.get_attribute('href')
17978
17979        # Discard the start tag:
17980        empty = reader.empty_element()
17981        reader.read()
17982        if empty:
17983            return objs
17984
17985        # Process the inner elements:
17986        while reader.forward():
17987            objs.append(VersionReader.read_one(reader))
17988
17989        # Discard the end tag:
17990        reader.read()
17991
17992        return objs
17993
17994
17995class VirtioScsiReader(Reader):
17996
17997    def __init__(self):
17998        super(VirtioScsiReader, self).__init__()
17999
18000    @staticmethod
18001    def read_one(reader):
18002        # Do nothing if there aren't more tags:
18003        if not reader.forward():
18004            return None
18005
18006        # Create the object:
18007        obj = types.VirtioScsi()
18008
18009        # Process the attributes:
18010        obj.href = reader.get_attribute('href')
18011
18012        # Discard the start tag:
18013        empty = reader.empty_element()
18014        reader.read()
18015        if empty:
18016            return obj
18017
18018        # Process the inner elements:
18019        links = []
18020        while reader.forward():
18021            tag = reader.node_name()
18022            if tag == 'enabled':
18023                obj.enabled = Reader.read_boolean(reader)
18024            else:
18025                reader.next_element()
18026        for link in links:
18027            VirtioScsiReader._process_link(link, obj)
18028
18029        # Discard the end tag:
18030        reader.read()
18031
18032        return obj
18033
18034    @staticmethod
18035    def read_many(reader):
18036        # Do nothing if there aren't more tags:
18037        objs = List()
18038        if not reader.forward():
18039            return objs
18040
18041        # Process the attributes:
18042        objs.href = reader.get_attribute('href')
18043
18044        # Discard the start tag:
18045        empty = reader.empty_element()
18046        reader.read()
18047        if empty:
18048            return objs
18049
18050        # Process the inner elements:
18051        while reader.forward():
18052            objs.append(VirtioScsiReader.read_one(reader))
18053
18054        # Discard the end tag:
18055        reader.read()
18056
18057        return objs
18058
18059
18060class VirtualNumaNodeReader(Reader):
18061
18062    def __init__(self):
18063        super(VirtualNumaNodeReader, self).__init__()
18064
18065    @staticmethod
18066    def read_one(reader):
18067        # Do nothing if there aren't more tags:
18068        if not reader.forward():
18069            return None
18070
18071        # Create the object:
18072        obj = types.VirtualNumaNode()
18073
18074        # Process the attributes:
18075        obj.href = reader.get_attribute('href')
18076        value = reader.get_attribute('id')
18077        if value is not None:
18078            obj.id = value
18079
18080        # Discard the start tag:
18081        empty = reader.empty_element()
18082        reader.read()
18083        if empty:
18084            return obj
18085
18086        # Process the inner elements:
18087        links = []
18088        while reader.forward():
18089            tag = reader.node_name()
18090            if tag == 'comment':
18091                obj.comment = Reader.read_string(reader)
18092            elif tag == 'cpu':
18093                obj.cpu = CpuReader.read_one(reader)
18094            elif tag == 'description':
18095                obj.description = Reader.read_string(reader)
18096            elif tag == 'host':
18097                obj.host = HostReader.read_one(reader)
18098            elif tag == 'index':
18099                obj.index = Reader.read_integer(reader)
18100            elif tag == 'memory':
18101                obj.memory = Reader.read_integer(reader)
18102            elif tag == 'name':
18103                obj.name = Reader.read_string(reader)
18104            elif tag == 'node_distance':
18105                obj.node_distance = Reader.read_string(reader)
18106            elif tag == 'numa_node_pins':
18107                obj.numa_node_pins = NumaNodePinReader.read_many(reader)
18108            elif tag == 'numa_tune_mode':
18109                obj.numa_tune_mode = Reader.read_enum(types.NumaTuneMode, reader)
18110            elif tag == 'statistics':
18111                obj.statistics = StatisticReader.read_many(reader)
18112            elif tag == 'vm':
18113                obj.vm = VmReader.read_one(reader)
18114            elif tag == 'link':
18115                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
18116                reader.next_element()
18117            else:
18118                reader.next_element()
18119        for link in links:
18120            VirtualNumaNodeReader._process_link(link, obj)
18121
18122        # Discard the end tag:
18123        reader.read()
18124
18125        return obj
18126
18127    @staticmethod
18128    def read_many(reader):
18129        # Do nothing if there aren't more tags:
18130        objs = List()
18131        if not reader.forward():
18132            return objs
18133
18134        # Process the attributes:
18135        objs.href = reader.get_attribute('href')
18136
18137        # Discard the start tag:
18138        empty = reader.empty_element()
18139        reader.read()
18140        if empty:
18141            return objs
18142
18143        # Process the inner elements:
18144        while reader.forward():
18145            objs.append(VirtualNumaNodeReader.read_one(reader))
18146
18147        # Discard the end tag:
18148        reader.read()
18149
18150        return objs
18151
18152    @staticmethod
18153    def _process_link(link, obj):
18154        # Process the attributes:
18155        rel = link[0]
18156        href = link[1]
18157        if href and rel:
18158            if rel == "statistics":
18159                if obj.statistics is not None:
18160                    obj.statistics.href = href
18161                else:
18162                    obj.statistics = List(href)
18163
18164
18165class VlanReader(Reader):
18166
18167    def __init__(self):
18168        super(VlanReader, self).__init__()
18169
18170    @staticmethod
18171    def read_one(reader):
18172        # Do nothing if there aren't more tags:
18173        if not reader.forward():
18174            return None
18175
18176        # Create the object:
18177        obj = types.Vlan()
18178
18179        # Process the attributes:
18180        obj.href = reader.get_attribute('href')
18181        value = reader.get_attribute('id')
18182        if value is not None:
18183            obj.id = Reader.parse_integer(value)
18184
18185        # Discard the start tag:
18186        empty = reader.empty_element()
18187        reader.read()
18188        if empty:
18189            return obj
18190
18191        # Process the inner elements:
18192        reader.next_element()
18193
18194        # Discard the end tag:
18195        reader.read()
18196
18197        return obj
18198
18199    @staticmethod
18200    def read_many(reader):
18201        # Do nothing if there aren't more tags:
18202        objs = List()
18203        if not reader.forward():
18204            return objs
18205
18206        # Process the attributes:
18207        objs.href = reader.get_attribute('href')
18208
18209        # Discard the start tag:
18210        empty = reader.empty_element()
18211        reader.read()
18212        if empty:
18213            return objs
18214
18215        # Process the inner elements:
18216        while reader.forward():
18217            objs.append(VlanReader.read_one(reader))
18218
18219        # Discard the end tag:
18220        reader.read()
18221
18222        return objs
18223
18224
18225class VmReader(Reader):
18226
18227    def __init__(self):
18228        super(VmReader, self).__init__()
18229
18230    @staticmethod
18231    def read_one(reader):
18232        # Do nothing if there aren't more tags:
18233        if not reader.forward():
18234            return None
18235
18236        # Create the object:
18237        obj = types.Vm()
18238
18239        # Process the attributes:
18240        obj.href = reader.get_attribute('href')
18241        value = reader.get_attribute('id')
18242        if value is not None:
18243            obj.id = value
18244
18245        # Discard the start tag:
18246        empty = reader.empty_element()
18247        reader.read()
18248        if empty:
18249            return obj
18250
18251        # Process the inner elements:
18252        links = []
18253        while reader.forward():
18254            tag = reader.node_name()
18255            if tag == 'affinity_labels':
18256                obj.affinity_labels = AffinityLabelReader.read_many(reader)
18257            elif tag == 'applications':
18258                obj.applications = ApplicationReader.read_many(reader)
18259            elif tag == 'auto_pinning_policy':
18260                obj.auto_pinning_policy = Reader.read_enum(types.AutoPinningPolicy, reader)
18261            elif tag == 'bios':
18262                obj.bios = BiosReader.read_one(reader)
18263            elif tag == 'cdroms':
18264                obj.cdroms = CdromReader.read_many(reader)
18265            elif tag == 'cluster':
18266                obj.cluster = ClusterReader.read_one(reader)
18267            elif tag == 'comment':
18268                obj.comment = Reader.read_string(reader)
18269            elif tag == 'console':
18270                obj.console = ConsoleReader.read_one(reader)
18271            elif tag == 'cpu':
18272                obj.cpu = CpuReader.read_one(reader)
18273            elif tag == 'cpu_pinning_policy':
18274                obj.cpu_pinning_policy = Reader.read_enum(types.CpuPinningPolicy, reader)
18275            elif tag == 'cpu_profile':
18276                obj.cpu_profile = CpuProfileReader.read_one(reader)
18277            elif tag == 'cpu_shares':
18278                obj.cpu_shares = Reader.read_integer(reader)
18279            elif tag == 'creation_time':
18280                obj.creation_time = Reader.read_date(reader)
18281            elif tag == 'custom_compatibility_version':
18282                obj.custom_compatibility_version = VersionReader.read_one(reader)
18283            elif tag == 'custom_cpu_model':
18284                obj.custom_cpu_model = Reader.read_string(reader)
18285            elif tag == 'custom_emulated_machine':
18286                obj.custom_emulated_machine = Reader.read_string(reader)
18287            elif tag == 'custom_properties':
18288                obj.custom_properties = CustomPropertyReader.read_many(reader)
18289            elif tag == 'delete_protected':
18290                obj.delete_protected = Reader.read_boolean(reader)
18291            elif tag == 'description':
18292                obj.description = Reader.read_string(reader)
18293            elif tag == 'disk_attachments':
18294                obj.disk_attachments = DiskAttachmentReader.read_many(reader)
18295            elif tag == 'display':
18296                obj.display = DisplayReader.read_one(reader)
18297            elif tag == 'domain':
18298                obj.domain = DomainReader.read_one(reader)
18299            elif tag == 'dynamic_cpu':
18300                obj.dynamic_cpu = DynamicCpuReader.read_one(reader)
18301            elif tag == 'external_host_provider':
18302                obj.external_host_provider = ExternalHostProviderReader.read_one(reader)
18303            elif tag == 'floppies':
18304                obj.floppies = FloppyReader.read_many(reader)
18305            elif tag == 'fqdn':
18306                obj.fqdn = Reader.read_string(reader)
18307            elif tag == 'graphics_consoles':
18308                obj.graphics_consoles = GraphicsConsoleReader.read_many(reader)
18309            elif tag == 'guest_operating_system':
18310                obj.guest_operating_system = GuestOperatingSystemReader.read_one(reader)
18311            elif tag == 'guest_time_zone':
18312                obj.guest_time_zone = TimeZoneReader.read_one(reader)
18313            elif tag == 'has_illegal_images':
18314                obj.has_illegal_images = Reader.read_boolean(reader)
18315            elif tag == 'high_availability':
18316                obj.high_availability = HighAvailabilityReader.read_one(reader)
18317            elif tag == 'host':
18318                obj.host = HostReader.read_one(reader)
18319            elif tag == 'host_devices':
18320                obj.host_devices = HostDeviceReader.read_many(reader)
18321            elif tag == 'initialization':
18322                obj.initialization = InitializationReader.read_one(reader)
18323            elif tag == 'instance_type':
18324                obj.instance_type = InstanceTypeReader.read_one(reader)
18325            elif tag == 'io':
18326                obj.io = IoReader.read_one(reader)
18327            elif tag == 'katello_errata':
18328                obj.katello_errata = KatelloErratumReader.read_many(reader)
18329            elif tag == 'large_icon':
18330                obj.large_icon = IconReader.read_one(reader)
18331            elif tag == 'lease':
18332                obj.lease = StorageDomainLeaseReader.read_one(reader)
18333            elif tag == 'mediated_devices':
18334                obj.mediated_devices = VmMediatedDeviceReader.read_many(reader)
18335            elif tag == 'memory':
18336                obj.memory = Reader.read_integer(reader)
18337            elif tag == 'memory_policy':
18338                obj.memory_policy = MemoryPolicyReader.read_one(reader)
18339            elif tag == 'migration':
18340                obj.migration = MigrationOptionsReader.read_one(reader)
18341            elif tag == 'migration_downtime':
18342                obj.migration_downtime = Reader.read_integer(reader)
18343            elif tag == 'multi_queues_enabled':
18344                obj.multi_queues_enabled = Reader.read_boolean(reader)
18345            elif tag == 'name':
18346                obj.name = Reader.read_string(reader)
18347            elif tag == 'next_run_configuration_exists':
18348                obj.next_run_configuration_exists = Reader.read_boolean(reader)
18349            elif tag == 'nics':
18350                obj.nics = NicReader.read_many(reader)
18351            elif tag == 'host_numa_nodes':
18352                obj.numa_nodes = NumaNodeReader.read_many(reader)
18353            elif tag == 'numa_tune_mode':
18354                obj.numa_tune_mode = Reader.read_enum(types.NumaTuneMode, reader)
18355            elif tag == 'origin':
18356                obj.origin = Reader.read_string(reader)
18357            elif tag == 'original_template':
18358                obj.original_template = TemplateReader.read_one(reader)
18359            elif tag == 'os':
18360                obj.os = OperatingSystemReader.read_one(reader)
18361            elif tag == 'payloads':
18362                obj.payloads = PayloadReader.read_many(reader)
18363            elif tag == 'permissions':
18364                obj.permissions = PermissionReader.read_many(reader)
18365            elif tag == 'placement_policy':
18366                obj.placement_policy = VmPlacementPolicyReader.read_one(reader)
18367            elif tag == 'quota':
18368                obj.quota = QuotaReader.read_one(reader)
18369            elif tag == 'reported_devices':
18370                obj.reported_devices = ReportedDeviceReader.read_many(reader)
18371            elif tag == 'rng_device':
18372                obj.rng_device = RngDeviceReader.read_one(reader)
18373            elif tag == 'run_once':
18374                obj.run_once = Reader.read_boolean(reader)
18375            elif tag == 'serial_number':
18376                obj.serial_number = SerialNumberReader.read_one(reader)
18377            elif tag == 'sessions':
18378                obj.sessions = SessionReader.read_many(reader)
18379            elif tag == 'small_icon':
18380                obj.small_icon = IconReader.read_one(reader)
18381            elif tag == 'snapshots':
18382                obj.snapshots = SnapshotReader.read_many(reader)
18383            elif tag == 'soundcard_enabled':
18384                obj.soundcard_enabled = Reader.read_boolean(reader)
18385            elif tag == 'sso':
18386                obj.sso = SsoReader.read_one(reader)
18387            elif tag == 'start_paused':
18388                obj.start_paused = Reader.read_boolean(reader)
18389            elif tag == 'start_time':
18390                obj.start_time = Reader.read_date(reader)
18391            elif tag == 'stateless':
18392                obj.stateless = Reader.read_boolean(reader)
18393            elif tag == 'statistics':
18394                obj.statistics = StatisticReader.read_many(reader)
18395            elif tag == 'status':
18396                obj.status = Reader.read_enum(types.VmStatus, reader)
18397            elif tag == 'status_detail':
18398                obj.status_detail = Reader.read_string(reader)
18399            elif tag == 'stop_reason':
18400                obj.stop_reason = Reader.read_string(reader)
18401            elif tag == 'stop_time':
18402                obj.stop_time = Reader.read_date(reader)
18403            elif tag == 'storage_domain':
18404                obj.storage_domain = StorageDomainReader.read_one(reader)
18405            elif tag == 'storage_error_resume_behaviour':
18406                obj.storage_error_resume_behaviour = Reader.read_enum(types.VmStorageErrorResumeBehaviour, reader)
18407            elif tag == 'tags':
18408                obj.tags = TagReader.read_many(reader)
18409            elif tag == 'template':
18410                obj.template = TemplateReader.read_one(reader)
18411            elif tag == 'time_zone':
18412                obj.time_zone = TimeZoneReader.read_one(reader)
18413            elif tag == 'tpm_enabled':
18414                obj.tpm_enabled = Reader.read_boolean(reader)
18415            elif tag == 'tunnel_migration':
18416                obj.tunnel_migration = Reader.read_boolean(reader)
18417            elif tag == 'type':
18418                obj.type = Reader.read_enum(types.VmType, reader)
18419            elif tag == 'usb':
18420                obj.usb = UsbReader.read_one(reader)
18421            elif tag == 'use_latest_template_version':
18422                obj.use_latest_template_version = Reader.read_boolean(reader)
18423            elif tag == 'virtio_scsi':
18424                obj.virtio_scsi = VirtioScsiReader.read_one(reader)
18425            elif tag == 'virtio_scsi_multi_queues':
18426                obj.virtio_scsi_multi_queues = Reader.read_integer(reader)
18427            elif tag == 'virtio_scsi_multi_queues_enabled':
18428                obj.virtio_scsi_multi_queues_enabled = Reader.read_boolean(reader)
18429            elif tag == 'vm_pool':
18430                obj.vm_pool = VmPoolReader.read_one(reader)
18431            elif tag == 'watchdogs':
18432                obj.watchdogs = WatchdogReader.read_many(reader)
18433            elif tag == 'link':
18434                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
18435                reader.next_element()
18436            else:
18437                reader.next_element()
18438        for link in links:
18439            VmReader._process_link(link, obj)
18440
18441        # Discard the end tag:
18442        reader.read()
18443
18444        return obj
18445
18446    @staticmethod
18447    def read_many(reader):
18448        # Do nothing if there aren't more tags:
18449        objs = List()
18450        if not reader.forward():
18451            return objs
18452
18453        # Process the attributes:
18454        objs.href = reader.get_attribute('href')
18455
18456        # Discard the start tag:
18457        empty = reader.empty_element()
18458        reader.read()
18459        if empty:
18460            return objs
18461
18462        # Process the inner elements:
18463        while reader.forward():
18464            objs.append(VmReader.read_one(reader))
18465
18466        # Discard the end tag:
18467        reader.read()
18468
18469        return objs
18470
18471    @staticmethod
18472    def _process_link(link, obj):
18473        # Process the attributes:
18474        rel = link[0]
18475        href = link[1]
18476        if href and rel:
18477            if rel == "affinitylabels":
18478                if obj.affinity_labels is not None:
18479                    obj.affinity_labels.href = href
18480                else:
18481                    obj.affinity_labels = List(href)
18482            elif rel == "applications":
18483                if obj.applications is not None:
18484                    obj.applications.href = href
18485                else:
18486                    obj.applications = List(href)
18487            elif rel == "cdroms":
18488                if obj.cdroms is not None:
18489                    obj.cdroms.href = href
18490                else:
18491                    obj.cdroms = List(href)
18492            elif rel == "diskattachments":
18493                if obj.disk_attachments is not None:
18494                    obj.disk_attachments.href = href
18495                else:
18496                    obj.disk_attachments = List(href)
18497            elif rel == "floppies":
18498                if obj.floppies is not None:
18499                    obj.floppies.href = href
18500                else:
18501                    obj.floppies = List(href)
18502            elif rel == "graphicsconsoles":
18503                if obj.graphics_consoles is not None:
18504                    obj.graphics_consoles.href = href
18505                else:
18506                    obj.graphics_consoles = List(href)
18507            elif rel == "hostdevices":
18508                if obj.host_devices is not None:
18509                    obj.host_devices.href = href
18510                else:
18511                    obj.host_devices = List(href)
18512            elif rel == "katelloerrata":
18513                if obj.katello_errata is not None:
18514                    obj.katello_errata.href = href
18515                else:
18516                    obj.katello_errata = List(href)
18517            elif rel == "mediateddevices":
18518                if obj.mediated_devices is not None:
18519                    obj.mediated_devices.href = href
18520                else:
18521                    obj.mediated_devices = List(href)
18522            elif rel == "nics":
18523                if obj.nics is not None:
18524                    obj.nics.href = href
18525                else:
18526                    obj.nics = List(href)
18527            elif rel == "numanodes":
18528                if obj.numa_nodes is not None:
18529                    obj.numa_nodes.href = href
18530                else:
18531                    obj.numa_nodes = List(href)
18532            elif rel == "permissions":
18533                if obj.permissions is not None:
18534                    obj.permissions.href = href
18535                else:
18536                    obj.permissions = List(href)
18537            elif rel == "reporteddevices":
18538                if obj.reported_devices is not None:
18539                    obj.reported_devices.href = href
18540                else:
18541                    obj.reported_devices = List(href)
18542            elif rel == "sessions":
18543                if obj.sessions is not None:
18544                    obj.sessions.href = href
18545                else:
18546                    obj.sessions = List(href)
18547            elif rel == "snapshots":
18548                if obj.snapshots is not None:
18549                    obj.snapshots.href = href
18550                else:
18551                    obj.snapshots = List(href)
18552            elif rel == "statistics":
18553                if obj.statistics is not None:
18554                    obj.statistics.href = href
18555                else:
18556                    obj.statistics = List(href)
18557            elif rel == "tags":
18558                if obj.tags is not None:
18559                    obj.tags.href = href
18560                else:
18561                    obj.tags = List(href)
18562            elif rel == "watchdogs":
18563                if obj.watchdogs is not None:
18564                    obj.watchdogs.href = href
18565                else:
18566                    obj.watchdogs = List(href)
18567
18568
18569class VmBaseReader(Reader):
18570
18571    def __init__(self):
18572        super(VmBaseReader, self).__init__()
18573
18574    @staticmethod
18575    def read_one(reader):
18576        # Do nothing if there aren't more tags:
18577        if not reader.forward():
18578            return None
18579
18580        # Create the object:
18581        obj = types.VmBase()
18582
18583        # Process the attributes:
18584        obj.href = reader.get_attribute('href')
18585        value = reader.get_attribute('id')
18586        if value is not None:
18587            obj.id = value
18588
18589        # Discard the start tag:
18590        empty = reader.empty_element()
18591        reader.read()
18592        if empty:
18593            return obj
18594
18595        # Process the inner elements:
18596        links = []
18597        while reader.forward():
18598            tag = reader.node_name()
18599            if tag == 'auto_pinning_policy':
18600                obj.auto_pinning_policy = Reader.read_enum(types.AutoPinningPolicy, reader)
18601            elif tag == 'bios':
18602                obj.bios = BiosReader.read_one(reader)
18603            elif tag == 'cluster':
18604                obj.cluster = ClusterReader.read_one(reader)
18605            elif tag == 'comment':
18606                obj.comment = Reader.read_string(reader)
18607            elif tag == 'console':
18608                obj.console = ConsoleReader.read_one(reader)
18609            elif tag == 'cpu':
18610                obj.cpu = CpuReader.read_one(reader)
18611            elif tag == 'cpu_pinning_policy':
18612                obj.cpu_pinning_policy = Reader.read_enum(types.CpuPinningPolicy, reader)
18613            elif tag == 'cpu_profile':
18614                obj.cpu_profile = CpuProfileReader.read_one(reader)
18615            elif tag == 'cpu_shares':
18616                obj.cpu_shares = Reader.read_integer(reader)
18617            elif tag == 'creation_time':
18618                obj.creation_time = Reader.read_date(reader)
18619            elif tag == 'custom_compatibility_version':
18620                obj.custom_compatibility_version = VersionReader.read_one(reader)
18621            elif tag == 'custom_cpu_model':
18622                obj.custom_cpu_model = Reader.read_string(reader)
18623            elif tag == 'custom_emulated_machine':
18624                obj.custom_emulated_machine = Reader.read_string(reader)
18625            elif tag == 'custom_properties':
18626                obj.custom_properties = CustomPropertyReader.read_many(reader)
18627            elif tag == 'delete_protected':
18628                obj.delete_protected = Reader.read_boolean(reader)
18629            elif tag == 'description':
18630                obj.description = Reader.read_string(reader)
18631            elif tag == 'display':
18632                obj.display = DisplayReader.read_one(reader)
18633            elif tag == 'domain':
18634                obj.domain = DomainReader.read_one(reader)
18635            elif tag == 'high_availability':
18636                obj.high_availability = HighAvailabilityReader.read_one(reader)
18637            elif tag == 'initialization':
18638                obj.initialization = InitializationReader.read_one(reader)
18639            elif tag == 'io':
18640                obj.io = IoReader.read_one(reader)
18641            elif tag == 'large_icon':
18642                obj.large_icon = IconReader.read_one(reader)
18643            elif tag == 'lease':
18644                obj.lease = StorageDomainLeaseReader.read_one(reader)
18645            elif tag == 'memory':
18646                obj.memory = Reader.read_integer(reader)
18647            elif tag == 'memory_policy':
18648                obj.memory_policy = MemoryPolicyReader.read_one(reader)
18649            elif tag == 'migration':
18650                obj.migration = MigrationOptionsReader.read_one(reader)
18651            elif tag == 'migration_downtime':
18652                obj.migration_downtime = Reader.read_integer(reader)
18653            elif tag == 'multi_queues_enabled':
18654                obj.multi_queues_enabled = Reader.read_boolean(reader)
18655            elif tag == 'name':
18656                obj.name = Reader.read_string(reader)
18657            elif tag == 'origin':
18658                obj.origin = Reader.read_string(reader)
18659            elif tag == 'os':
18660                obj.os = OperatingSystemReader.read_one(reader)
18661            elif tag == 'placement_policy':
18662                obj.placement_policy = VmPlacementPolicyReader.read_one(reader)
18663            elif tag == 'quota':
18664                obj.quota = QuotaReader.read_one(reader)
18665            elif tag == 'rng_device':
18666                obj.rng_device = RngDeviceReader.read_one(reader)
18667            elif tag == 'serial_number':
18668                obj.serial_number = SerialNumberReader.read_one(reader)
18669            elif tag == 'small_icon':
18670                obj.small_icon = IconReader.read_one(reader)
18671            elif tag == 'soundcard_enabled':
18672                obj.soundcard_enabled = Reader.read_boolean(reader)
18673            elif tag == 'sso':
18674                obj.sso = SsoReader.read_one(reader)
18675            elif tag == 'start_paused':
18676                obj.start_paused = Reader.read_boolean(reader)
18677            elif tag == 'stateless':
18678                obj.stateless = Reader.read_boolean(reader)
18679            elif tag == 'storage_domain':
18680                obj.storage_domain = StorageDomainReader.read_one(reader)
18681            elif tag == 'storage_error_resume_behaviour':
18682                obj.storage_error_resume_behaviour = Reader.read_enum(types.VmStorageErrorResumeBehaviour, reader)
18683            elif tag == 'time_zone':
18684                obj.time_zone = TimeZoneReader.read_one(reader)
18685            elif tag == 'tpm_enabled':
18686                obj.tpm_enabled = Reader.read_boolean(reader)
18687            elif tag == 'tunnel_migration':
18688                obj.tunnel_migration = Reader.read_boolean(reader)
18689            elif tag == 'type':
18690                obj.type = Reader.read_enum(types.VmType, reader)
18691            elif tag == 'usb':
18692                obj.usb = UsbReader.read_one(reader)
18693            elif tag == 'virtio_scsi':
18694                obj.virtio_scsi = VirtioScsiReader.read_one(reader)
18695            elif tag == 'virtio_scsi_multi_queues':
18696                obj.virtio_scsi_multi_queues = Reader.read_integer(reader)
18697            elif tag == 'virtio_scsi_multi_queues_enabled':
18698                obj.virtio_scsi_multi_queues_enabled = Reader.read_boolean(reader)
18699            else:
18700                reader.next_element()
18701        for link in links:
18702            VmBaseReader._process_link(link, obj)
18703
18704        # Discard the end tag:
18705        reader.read()
18706
18707        return obj
18708
18709    @staticmethod
18710    def read_many(reader):
18711        # Do nothing if there aren't more tags:
18712        objs = List()
18713        if not reader.forward():
18714            return objs
18715
18716        # Process the attributes:
18717        objs.href = reader.get_attribute('href')
18718
18719        # Discard the start tag:
18720        empty = reader.empty_element()
18721        reader.read()
18722        if empty:
18723            return objs
18724
18725        # Process the inner elements:
18726        while reader.forward():
18727            objs.append(VmBaseReader.read_one(reader))
18728
18729        # Discard the end tag:
18730        reader.read()
18731
18732        return objs
18733
18734
18735class VmMediatedDeviceReader(Reader):
18736
18737    def __init__(self):
18738        super(VmMediatedDeviceReader, self).__init__()
18739
18740    @staticmethod
18741    def read_one(reader):
18742        # Do nothing if there aren't more tags:
18743        if not reader.forward():
18744            return None
18745
18746        # Create the object:
18747        obj = types.VmMediatedDevice()
18748
18749        # Process the attributes:
18750        obj.href = reader.get_attribute('href')
18751        value = reader.get_attribute('id')
18752        if value is not None:
18753            obj.id = value
18754
18755        # Discard the start tag:
18756        empty = reader.empty_element()
18757        reader.read()
18758        if empty:
18759            return obj
18760
18761        # Process the inner elements:
18762        links = []
18763        while reader.forward():
18764            tag = reader.node_name()
18765            if tag == 'comment':
18766                obj.comment = Reader.read_string(reader)
18767            elif tag == 'description':
18768                obj.description = Reader.read_string(reader)
18769            elif tag == 'instance_type':
18770                obj.instance_type = InstanceTypeReader.read_one(reader)
18771            elif tag == 'name':
18772                obj.name = Reader.read_string(reader)
18773            elif tag == 'spec_params':
18774                obj.spec_params = PropertyReader.read_many(reader)
18775            elif tag == 'template':
18776                obj.template = TemplateReader.read_one(reader)
18777            elif tag == 'vm':
18778                obj.vm = VmReader.read_one(reader)
18779            elif tag == 'vms':
18780                obj.vms = VmReader.read_many(reader)
18781            elif tag == 'link':
18782                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
18783                reader.next_element()
18784            else:
18785                reader.next_element()
18786        for link in links:
18787            VmMediatedDeviceReader._process_link(link, obj)
18788
18789        # Discard the end tag:
18790        reader.read()
18791
18792        return obj
18793
18794    @staticmethod
18795    def read_many(reader):
18796        # Do nothing if there aren't more tags:
18797        objs = List()
18798        if not reader.forward():
18799            return objs
18800
18801        # Process the attributes:
18802        objs.href = reader.get_attribute('href')
18803
18804        # Discard the start tag:
18805        empty = reader.empty_element()
18806        reader.read()
18807        if empty:
18808            return objs
18809
18810        # Process the inner elements:
18811        while reader.forward():
18812            objs.append(VmMediatedDeviceReader.read_one(reader))
18813
18814        # Discard the end tag:
18815        reader.read()
18816
18817        return objs
18818
18819    @staticmethod
18820    def _process_link(link, obj):
18821        # Process the attributes:
18822        rel = link[0]
18823        href = link[1]
18824        if href and rel:
18825            if rel == "vms":
18826                if obj.vms is not None:
18827                    obj.vms.href = href
18828                else:
18829                    obj.vms = List(href)
18830
18831
18832class VmPlacementPolicyReader(Reader):
18833
18834    def __init__(self):
18835        super(VmPlacementPolicyReader, self).__init__()
18836
18837    @staticmethod
18838    def read_one(reader):
18839        # Do nothing if there aren't more tags:
18840        if not reader.forward():
18841            return None
18842
18843        # Create the object:
18844        obj = types.VmPlacementPolicy()
18845
18846        # Process the attributes:
18847        obj.href = reader.get_attribute('href')
18848
18849        # Discard the start tag:
18850        empty = reader.empty_element()
18851        reader.read()
18852        if empty:
18853            return obj
18854
18855        # Process the inner elements:
18856        links = []
18857        while reader.forward():
18858            tag = reader.node_name()
18859            if tag == 'affinity':
18860                obj.affinity = Reader.read_enum(types.VmAffinity, reader)
18861            elif tag == 'hosts':
18862                obj.hosts = HostReader.read_many(reader)
18863            elif tag == 'link':
18864                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
18865                reader.next_element()
18866            else:
18867                reader.next_element()
18868        for link in links:
18869            VmPlacementPolicyReader._process_link(link, obj)
18870
18871        # Discard the end tag:
18872        reader.read()
18873
18874        return obj
18875
18876    @staticmethod
18877    def read_many(reader):
18878        # Do nothing if there aren't more tags:
18879        objs = List()
18880        if not reader.forward():
18881            return objs
18882
18883        # Process the attributes:
18884        objs.href = reader.get_attribute('href')
18885
18886        # Discard the start tag:
18887        empty = reader.empty_element()
18888        reader.read()
18889        if empty:
18890            return objs
18891
18892        # Process the inner elements:
18893        while reader.forward():
18894            objs.append(VmPlacementPolicyReader.read_one(reader))
18895
18896        # Discard the end tag:
18897        reader.read()
18898
18899        return objs
18900
18901    @staticmethod
18902    def _process_link(link, obj):
18903        # Process the attributes:
18904        rel = link[0]
18905        href = link[1]
18906        if href and rel:
18907            if rel == "hosts":
18908                if obj.hosts is not None:
18909                    obj.hosts.href = href
18910                else:
18911                    obj.hosts = List(href)
18912
18913
18914class VmPoolReader(Reader):
18915
18916    def __init__(self):
18917        super(VmPoolReader, self).__init__()
18918
18919    @staticmethod
18920    def read_one(reader):
18921        # Do nothing if there aren't more tags:
18922        if not reader.forward():
18923            return None
18924
18925        # Create the object:
18926        obj = types.VmPool()
18927
18928        # Process the attributes:
18929        obj.href = reader.get_attribute('href')
18930        value = reader.get_attribute('id')
18931        if value is not None:
18932            obj.id = value
18933
18934        # Discard the start tag:
18935        empty = reader.empty_element()
18936        reader.read()
18937        if empty:
18938            return obj
18939
18940        # Process the inner elements:
18941        links = []
18942        while reader.forward():
18943            tag = reader.node_name()
18944            if tag == 'auto_storage_select':
18945                obj.auto_storage_select = Reader.read_boolean(reader)
18946            elif tag == 'cluster':
18947                obj.cluster = ClusterReader.read_one(reader)
18948            elif tag == 'comment':
18949                obj.comment = Reader.read_string(reader)
18950            elif tag == 'description':
18951                obj.description = Reader.read_string(reader)
18952            elif tag == 'display':
18953                obj.display = DisplayReader.read_one(reader)
18954            elif tag == 'instance_type':
18955                obj.instance_type = InstanceTypeReader.read_one(reader)
18956            elif tag == 'max_user_vms':
18957                obj.max_user_vms = Reader.read_integer(reader)
18958            elif tag == 'name':
18959                obj.name = Reader.read_string(reader)
18960            elif tag == 'permissions':
18961                obj.permissions = PermissionReader.read_many(reader)
18962            elif tag == 'prestarted_vms':
18963                obj.prestarted_vms = Reader.read_integer(reader)
18964            elif tag == 'rng_device':
18965                obj.rng_device = RngDeviceReader.read_one(reader)
18966            elif tag == 'size':
18967                obj.size = Reader.read_integer(reader)
18968            elif tag == 'soundcard_enabled':
18969                obj.soundcard_enabled = Reader.read_boolean(reader)
18970            elif tag == 'stateful':
18971                obj.stateful = Reader.read_boolean(reader)
18972            elif tag == 'template':
18973                obj.template = TemplateReader.read_one(reader)
18974            elif tag == 'tpm_enabled':
18975                obj.tpm_enabled = Reader.read_boolean(reader)
18976            elif tag == 'type':
18977                obj.type = Reader.read_enum(types.VmPoolType, reader)
18978            elif tag == 'use_latest_template_version':
18979                obj.use_latest_template_version = Reader.read_boolean(reader)
18980            elif tag == 'vm':
18981                obj.vm = VmReader.read_one(reader)
18982            elif tag == 'link':
18983                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
18984                reader.next_element()
18985            else:
18986                reader.next_element()
18987        for link in links:
18988            VmPoolReader._process_link(link, obj)
18989
18990        # Discard the end tag:
18991        reader.read()
18992
18993        return obj
18994
18995    @staticmethod
18996    def read_many(reader):
18997        # Do nothing if there aren't more tags:
18998        objs = List()
18999        if not reader.forward():
19000            return objs
19001
19002        # Process the attributes:
19003        objs.href = reader.get_attribute('href')
19004
19005        # Discard the start tag:
19006        empty = reader.empty_element()
19007        reader.read()
19008        if empty:
19009            return objs
19010
19011        # Process the inner elements:
19012        while reader.forward():
19013            objs.append(VmPoolReader.read_one(reader))
19014
19015        # Discard the end tag:
19016        reader.read()
19017
19018        return objs
19019
19020    @staticmethod
19021    def _process_link(link, obj):
19022        # Process the attributes:
19023        rel = link[0]
19024        href = link[1]
19025        if href and rel:
19026            if rel == "permissions":
19027                if obj.permissions is not None:
19028                    obj.permissions.href = href
19029                else:
19030                    obj.permissions = List(href)
19031
19032
19033class VmSummaryReader(Reader):
19034
19035    def __init__(self):
19036        super(VmSummaryReader, self).__init__()
19037
19038    @staticmethod
19039    def read_one(reader):
19040        # Do nothing if there aren't more tags:
19041        if not reader.forward():
19042            return None
19043
19044        # Create the object:
19045        obj = types.VmSummary()
19046
19047        # Process the attributes:
19048        obj.href = reader.get_attribute('href')
19049
19050        # Discard the start tag:
19051        empty = reader.empty_element()
19052        reader.read()
19053        if empty:
19054            return obj
19055
19056        # Process the inner elements:
19057        links = []
19058        while reader.forward():
19059            tag = reader.node_name()
19060            if tag == 'active':
19061                obj.active = Reader.read_integer(reader)
19062            elif tag == 'migrating':
19063                obj.migrating = Reader.read_integer(reader)
19064            elif tag == 'total':
19065                obj.total = Reader.read_integer(reader)
19066            else:
19067                reader.next_element()
19068        for link in links:
19069            VmSummaryReader._process_link(link, obj)
19070
19071        # Discard the end tag:
19072        reader.read()
19073
19074        return obj
19075
19076    @staticmethod
19077    def read_many(reader):
19078        # Do nothing if there aren't more tags:
19079        objs = List()
19080        if not reader.forward():
19081            return objs
19082
19083        # Process the attributes:
19084        objs.href = reader.get_attribute('href')
19085
19086        # Discard the start tag:
19087        empty = reader.empty_element()
19088        reader.read()
19089        if empty:
19090            return objs
19091
19092        # Process the inner elements:
19093        while reader.forward():
19094            objs.append(VmSummaryReader.read_one(reader))
19095
19096        # Discard the end tag:
19097        reader.read()
19098
19099        return objs
19100
19101
19102class VnicPassThroughReader(Reader):
19103
19104    def __init__(self):
19105        super(VnicPassThroughReader, self).__init__()
19106
19107    @staticmethod
19108    def read_one(reader):
19109        # Do nothing if there aren't more tags:
19110        if not reader.forward():
19111            return None
19112
19113        # Create the object:
19114        obj = types.VnicPassThrough()
19115
19116        # Process the attributes:
19117        obj.href = reader.get_attribute('href')
19118
19119        # Discard the start tag:
19120        empty = reader.empty_element()
19121        reader.read()
19122        if empty:
19123            return obj
19124
19125        # Process the inner elements:
19126        links = []
19127        while reader.forward():
19128            tag = reader.node_name()
19129            if tag == 'mode':
19130                obj.mode = Reader.read_enum(types.VnicPassThroughMode, reader)
19131            else:
19132                reader.next_element()
19133        for link in links:
19134            VnicPassThroughReader._process_link(link, obj)
19135
19136        # Discard the end tag:
19137        reader.read()
19138
19139        return obj
19140
19141    @staticmethod
19142    def read_many(reader):
19143        # Do nothing if there aren't more tags:
19144        objs = List()
19145        if not reader.forward():
19146            return objs
19147
19148        # Process the attributes:
19149        objs.href = reader.get_attribute('href')
19150
19151        # Discard the start tag:
19152        empty = reader.empty_element()
19153        reader.read()
19154        if empty:
19155            return objs
19156
19157        # Process the inner elements:
19158        while reader.forward():
19159            objs.append(VnicPassThroughReader.read_one(reader))
19160
19161        # Discard the end tag:
19162        reader.read()
19163
19164        return objs
19165
19166
19167class VnicProfileReader(Reader):
19168
19169    def __init__(self):
19170        super(VnicProfileReader, self).__init__()
19171
19172    @staticmethod
19173    def read_one(reader):
19174        # Do nothing if there aren't more tags:
19175        if not reader.forward():
19176            return None
19177
19178        # Create the object:
19179        obj = types.VnicProfile()
19180
19181        # Process the attributes:
19182        obj.href = reader.get_attribute('href')
19183        value = reader.get_attribute('id')
19184        if value is not None:
19185            obj.id = value
19186
19187        # Discard the start tag:
19188        empty = reader.empty_element()
19189        reader.read()
19190        if empty:
19191            return obj
19192
19193        # Process the inner elements:
19194        links = []
19195        while reader.forward():
19196            tag = reader.node_name()
19197            if tag == 'comment':
19198                obj.comment = Reader.read_string(reader)
19199            elif tag == 'custom_properties':
19200                obj.custom_properties = CustomPropertyReader.read_many(reader)
19201            elif tag == 'description':
19202                obj.description = Reader.read_string(reader)
19203            elif tag == 'failover':
19204                obj.failover = VnicProfileReader.read_one(reader)
19205            elif tag == 'migratable':
19206                obj.migratable = Reader.read_boolean(reader)
19207            elif tag == 'name':
19208                obj.name = Reader.read_string(reader)
19209            elif tag == 'network':
19210                obj.network = NetworkReader.read_one(reader)
19211            elif tag == 'network_filter':
19212                obj.network_filter = NetworkFilterReader.read_one(reader)
19213            elif tag == 'pass_through':
19214                obj.pass_through = VnicPassThroughReader.read_one(reader)
19215            elif tag == 'permissions':
19216                obj.permissions = PermissionReader.read_many(reader)
19217            elif tag == 'port_mirroring':
19218                obj.port_mirroring = Reader.read_boolean(reader)
19219            elif tag == 'qos':
19220                obj.qos = QosReader.read_one(reader)
19221            elif tag == 'link':
19222                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
19223                reader.next_element()
19224            else:
19225                reader.next_element()
19226        for link in links:
19227            VnicProfileReader._process_link(link, obj)
19228
19229        # Discard the end tag:
19230        reader.read()
19231
19232        return obj
19233
19234    @staticmethod
19235    def read_many(reader):
19236        # Do nothing if there aren't more tags:
19237        objs = List()
19238        if not reader.forward():
19239            return objs
19240
19241        # Process the attributes:
19242        objs.href = reader.get_attribute('href')
19243
19244        # Discard the start tag:
19245        empty = reader.empty_element()
19246        reader.read()
19247        if empty:
19248            return objs
19249
19250        # Process the inner elements:
19251        while reader.forward():
19252            objs.append(VnicProfileReader.read_one(reader))
19253
19254        # Discard the end tag:
19255        reader.read()
19256
19257        return objs
19258
19259    @staticmethod
19260    def _process_link(link, obj):
19261        # Process the attributes:
19262        rel = link[0]
19263        href = link[1]
19264        if href and rel:
19265            if rel == "permissions":
19266                if obj.permissions is not None:
19267                    obj.permissions.href = href
19268                else:
19269                    obj.permissions = List(href)
19270
19271
19272class VnicProfileMappingReader(Reader):
19273
19274    def __init__(self):
19275        super(VnicProfileMappingReader, self).__init__()
19276
19277    @staticmethod
19278    def read_one(reader):
19279        # Do nothing if there aren't more tags:
19280        if not reader.forward():
19281            return None
19282
19283        # Create the object:
19284        obj = types.VnicProfileMapping()
19285
19286        # Process the attributes:
19287        obj.href = reader.get_attribute('href')
19288
19289        # Discard the start tag:
19290        empty = reader.empty_element()
19291        reader.read()
19292        if empty:
19293            return obj
19294
19295        # Process the inner elements:
19296        links = []
19297        while reader.forward():
19298            tag = reader.node_name()
19299            if tag == 'source_network_name':
19300                obj.source_network_name = Reader.read_string(reader)
19301            elif tag == 'source_network_profile_name':
19302                obj.source_network_profile_name = Reader.read_string(reader)
19303            elif tag == 'target_vnic_profile':
19304                obj.target_vnic_profile = VnicProfileReader.read_one(reader)
19305            else:
19306                reader.next_element()
19307        for link in links:
19308            VnicProfileMappingReader._process_link(link, obj)
19309
19310        # Discard the end tag:
19311        reader.read()
19312
19313        return obj
19314
19315    @staticmethod
19316    def read_many(reader):
19317        # Do nothing if there aren't more tags:
19318        objs = List()
19319        if not reader.forward():
19320            return objs
19321
19322        # Process the attributes:
19323        objs.href = reader.get_attribute('href')
19324
19325        # Discard the start tag:
19326        empty = reader.empty_element()
19327        reader.read()
19328        if empty:
19329            return objs
19330
19331        # Process the inner elements:
19332        while reader.forward():
19333            objs.append(VnicProfileMappingReader.read_one(reader))
19334
19335        # Discard the end tag:
19336        reader.read()
19337
19338        return objs
19339
19340
19341class VolumeGroupReader(Reader):
19342
19343    def __init__(self):
19344        super(VolumeGroupReader, self).__init__()
19345
19346    @staticmethod
19347    def read_one(reader):
19348        # Do nothing if there aren't more tags:
19349        if not reader.forward():
19350            return None
19351
19352        # Create the object:
19353        obj = types.VolumeGroup()
19354
19355        # Process the attributes:
19356        obj.href = reader.get_attribute('href')
19357        value = reader.get_attribute('id')
19358        if value is not None:
19359            obj.id = value
19360
19361        # Discard the start tag:
19362        empty = reader.empty_element()
19363        reader.read()
19364        if empty:
19365            return obj
19366
19367        # Process the inner elements:
19368        links = []
19369        while reader.forward():
19370            tag = reader.node_name()
19371            if tag == 'logical_units':
19372                obj.logical_units = LogicalUnitReader.read_many(reader)
19373            elif tag == 'name':
19374                obj.name = Reader.read_string(reader)
19375            else:
19376                reader.next_element()
19377        for link in links:
19378            VolumeGroupReader._process_link(link, obj)
19379
19380        # Discard the end tag:
19381        reader.read()
19382
19383        return obj
19384
19385    @staticmethod
19386    def read_many(reader):
19387        # Do nothing if there aren't more tags:
19388        objs = List()
19389        if not reader.forward():
19390            return objs
19391
19392        # Process the attributes:
19393        objs.href = reader.get_attribute('href')
19394
19395        # Discard the start tag:
19396        empty = reader.empty_element()
19397        reader.read()
19398        if empty:
19399            return objs
19400
19401        # Process the inner elements:
19402        while reader.forward():
19403            objs.append(VolumeGroupReader.read_one(reader))
19404
19405        # Discard the end tag:
19406        reader.read()
19407
19408        return objs
19409
19410
19411class WatchdogReader(Reader):
19412
19413    def __init__(self):
19414        super(WatchdogReader, self).__init__()
19415
19416    @staticmethod
19417    def read_one(reader):
19418        # Do nothing if there aren't more tags:
19419        if not reader.forward():
19420            return None
19421
19422        # Create the object:
19423        obj = types.Watchdog()
19424
19425        # Process the attributes:
19426        obj.href = reader.get_attribute('href')
19427        value = reader.get_attribute('id')
19428        if value is not None:
19429            obj.id = value
19430
19431        # Discard the start tag:
19432        empty = reader.empty_element()
19433        reader.read()
19434        if empty:
19435            return obj
19436
19437        # Process the inner elements:
19438        links = []
19439        while reader.forward():
19440            tag = reader.node_name()
19441            if tag == 'action':
19442                obj.action = Reader.read_enum(types.WatchdogAction, reader)
19443            elif tag == 'comment':
19444                obj.comment = Reader.read_string(reader)
19445            elif tag == 'description':
19446                obj.description = Reader.read_string(reader)
19447            elif tag == 'instance_type':
19448                obj.instance_type = InstanceTypeReader.read_one(reader)
19449            elif tag == 'model':
19450                obj.model = Reader.read_enum(types.WatchdogModel, reader)
19451            elif tag == 'name':
19452                obj.name = Reader.read_string(reader)
19453            elif tag == 'template':
19454                obj.template = TemplateReader.read_one(reader)
19455            elif tag == 'vm':
19456                obj.vm = VmReader.read_one(reader)
19457            elif tag == 'vms':
19458                obj.vms = VmReader.read_many(reader)
19459            elif tag == 'link':
19460                links.append((reader.get_attribute('rel'), reader.get_attribute('href')))
19461                reader.next_element()
19462            else:
19463                reader.next_element()
19464        for link in links:
19465            WatchdogReader._process_link(link, obj)
19466
19467        # Discard the end tag:
19468        reader.read()
19469
19470        return obj
19471
19472    @staticmethod
19473    def read_many(reader):
19474        # Do nothing if there aren't more tags:
19475        objs = List()
19476        if not reader.forward():
19477            return objs
19478
19479        # Process the attributes:
19480        objs.href = reader.get_attribute('href')
19481
19482        # Discard the start tag:
19483        empty = reader.empty_element()
19484        reader.read()
19485        if empty:
19486            return objs
19487
19488        # Process the inner elements:
19489        while reader.forward():
19490            objs.append(WatchdogReader.read_one(reader))
19491
19492        # Discard the end tag:
19493        reader.read()
19494
19495        return objs
19496
19497    @staticmethod
19498    def _process_link(link, obj):
19499        # Process the attributes:
19500        rel = link[0]
19501        href = link[1]
19502        if href and rel:
19503            if rel == "vms":
19504                if obj.vms is not None:
19505                    obj.vms.href = href
19506                else:
19507                    obj.vms = List(href)
19508
19509
19510class WeightReader(Reader):
19511
19512    def __init__(self):
19513        super(WeightReader, self).__init__()
19514
19515    @staticmethod
19516    def read_one(reader):
19517        # Do nothing if there aren't more tags:
19518        if not reader.forward():
19519            return None
19520
19521        # Create the object:
19522        obj = types.Weight()
19523
19524        # Process the attributes:
19525        obj.href = reader.get_attribute('href')
19526        value = reader.get_attribute('id')
19527        if value is not None:
19528            obj.id = value
19529
19530        # Discard the start tag:
19531        empty = reader.empty_element()
19532        reader.read()
19533        if empty:
19534            return obj
19535
19536        # Process the inner elements:
19537        links = []
19538        while reader.forward():
19539            tag = reader.node_name()
19540            if tag == 'comment':
19541                obj.comment = Reader.read_string(reader)
19542            elif tag == 'description':
19543                obj.description = Reader.read_string(reader)
19544            elif tag == 'factor':
19545                obj.factor = Reader.read_integer(reader)
19546            elif tag == 'name':
19547                obj.name = Reader.read_string(reader)
19548            elif tag == 'scheduling_policy':
19549                obj.scheduling_policy = SchedulingPolicyReader.read_one(reader)
19550            elif tag == 'scheduling_policy_unit':
19551                obj.scheduling_policy_unit = SchedulingPolicyUnitReader.read_one(reader)
19552            else:
19553                reader.next_element()
19554        for link in links:
19555            WeightReader._process_link(link, obj)
19556
19557        # Discard the end tag:
19558        reader.read()
19559
19560        return obj
19561
19562    @staticmethod
19563    def read_many(reader):
19564        # Do nothing if there aren't more tags:
19565        objs = List()
19566        if not reader.forward():
19567            return objs
19568
19569        # Process the attributes:
19570        objs.href = reader.get_attribute('href')
19571
19572        # Discard the start tag:
19573        empty = reader.empty_element()
19574        reader.read()
19575        if empty:
19576            return objs
19577
19578        # Process the inner elements:
19579        while reader.forward():
19580            objs.append(WeightReader.read_one(reader))
19581
19582        # Discard the end tag:
19583        reader.read()
19584
19585        return objs
19586
19587
19588Reader.register('action', ActionReader.read_one)
19589Reader.register('actions', ActionReader.read_many)
19590Reader.register('affinity_group', AffinityGroupReader.read_one)
19591Reader.register('affinity_groups', AffinityGroupReader.read_many)
19592Reader.register('affinity_label', AffinityLabelReader.read_one)
19593Reader.register('affinity_labels', AffinityLabelReader.read_many)
19594Reader.register('affinity_rule', AffinityRuleReader.read_one)
19595Reader.register('affinity_rules', AffinityRuleReader.read_many)
19596Reader.register('agent', AgentReader.read_one)
19597Reader.register('agents', AgentReader.read_many)
19598Reader.register('agent_configuration', AgentConfigurationReader.read_one)
19599Reader.register('agent_configurations', AgentConfigurationReader.read_many)
19600Reader.register('api', ApiReader.read_one)
19601Reader.register('apis', ApiReader.read_many)
19602Reader.register('api_summary', ApiSummaryReader.read_one)
19603Reader.register('api_summaries', ApiSummaryReader.read_many)
19604Reader.register('api_summary_item', ApiSummaryItemReader.read_one)
19605Reader.register('api_summary_items', ApiSummaryItemReader.read_many)
19606Reader.register('application', ApplicationReader.read_one)
19607Reader.register('applications', ApplicationReader.read_many)
19608Reader.register('authorized_key', AuthorizedKeyReader.read_one)
19609Reader.register('authorized_keys', AuthorizedKeyReader.read_many)
19610Reader.register('backup', BackupReader.read_one)
19611Reader.register('backups', BackupReader.read_many)
19612Reader.register('balance', BalanceReader.read_one)
19613Reader.register('balances', BalanceReader.read_many)
19614Reader.register('bios', BiosReader.read_one)
19615Reader.register('bioss', BiosReader.read_many)
19616Reader.register('block_statistic', BlockStatisticReader.read_one)
19617Reader.register('block_statistics', BlockStatisticReader.read_many)
19618Reader.register('bonding', BondingReader.read_one)
19619Reader.register('bondings', BondingReader.read_many)
19620Reader.register('bookmark', BookmarkReader.read_one)
19621Reader.register('bookmarks', BookmarkReader.read_many)
19622Reader.register('boot', BootReader.read_one)
19623Reader.register('boots', BootReader.read_many)
19624Reader.register('boot_menu', BootMenuReader.read_one)
19625Reader.register('boot_menus', BootMenuReader.read_many)
19626Reader.register('brick_profile_detail', BrickProfileDetailReader.read_one)
19627Reader.register('brick_profile_details', BrickProfileDetailReader.read_many)
19628Reader.register('cdrom', CdromReader.read_one)
19629Reader.register('cdroms', CdromReader.read_many)
19630Reader.register('certificate', CertificateReader.read_one)
19631Reader.register('certificates', CertificateReader.read_many)
19632Reader.register('checkpoint', CheckpointReader.read_one)
19633Reader.register('checkpoints', CheckpointReader.read_many)
19634Reader.register('cloud_init', CloudInitReader.read_one)
19635Reader.register('cloud_inits', CloudInitReader.read_many)
19636Reader.register('cluster', ClusterReader.read_one)
19637Reader.register('clusters', ClusterReader.read_many)
19638Reader.register('cluster_feature', ClusterFeatureReader.read_one)
19639Reader.register('cluster_features', ClusterFeatureReader.read_many)
19640Reader.register('cluster_level', ClusterLevelReader.read_one)
19641Reader.register('cluster_levels', ClusterLevelReader.read_many)
19642Reader.register('configuration', ConfigurationReader.read_one)
19643Reader.register('configurations', ConfigurationReader.read_many)
19644Reader.register('console', ConsoleReader.read_one)
19645Reader.register('consoles', ConsoleReader.read_many)
19646Reader.register('core', CoreReader.read_one)
19647Reader.register('cores', CoreReader.read_many)
19648Reader.register('cpu', CpuReader.read_one)
19649Reader.register('cpus', CpuReader.read_many)
19650Reader.register('cpu_profile', CpuProfileReader.read_one)
19651Reader.register('cpu_profiles', CpuProfileReader.read_many)
19652Reader.register('cpu_topology', CpuTopologyReader.read_one)
19653Reader.register('cpu_topologies', CpuTopologyReader.read_many)
19654Reader.register('cpu_tune', CpuTuneReader.read_one)
19655Reader.register('cpu_tunes', CpuTuneReader.read_many)
19656Reader.register('cpu_type', CpuTypeReader.read_one)
19657Reader.register('cpu_types', CpuTypeReader.read_many)
19658Reader.register('custom_property', CustomPropertyReader.read_one)
19659Reader.register('custom_properties', CustomPropertyReader.read_many)
19660Reader.register('data_center', DataCenterReader.read_one)
19661Reader.register('data_centers', DataCenterReader.read_many)
19662Reader.register('device', DeviceReader.read_one)
19663Reader.register('devices', DeviceReader.read_many)
19664Reader.register('disk', DiskReader.read_one)
19665Reader.register('disks', DiskReader.read_many)
19666Reader.register('disk_attachment', DiskAttachmentReader.read_one)
19667Reader.register('disk_attachments', DiskAttachmentReader.read_many)
19668Reader.register('disk_profile', DiskProfileReader.read_one)
19669Reader.register('disk_profiles', DiskProfileReader.read_many)
19670Reader.register('disk_snapshot', DiskSnapshotReader.read_one)
19671Reader.register('disk_snapshots', DiskSnapshotReader.read_many)
19672Reader.register('display', DisplayReader.read_one)
19673Reader.register('displays', DisplayReader.read_many)
19674Reader.register('dns', DnsReader.read_one)
19675Reader.register('dnss', DnsReader.read_many)
19676Reader.register('dns_resolver_configuration', DnsResolverConfigurationReader.read_one)
19677Reader.register('dns_resolver_configurations', DnsResolverConfigurationReader.read_many)
19678Reader.register('domain', DomainReader.read_one)
19679Reader.register('domains', DomainReader.read_many)
19680Reader.register('dynamic_cpu', DynamicCpuReader.read_one)
19681Reader.register('dynamic_cpus', DynamicCpuReader.read_many)
19682Reader.register('entity_profile_detail', EntityProfileDetailReader.read_one)
19683Reader.register('entity_profile_details', EntityProfileDetailReader.read_many)
19684Reader.register('error_handling', ErrorHandlingReader.read_one)
19685Reader.register('error_handlings', ErrorHandlingReader.read_many)
19686Reader.register('event', EventReader.read_one)
19687Reader.register('events', EventReader.read_many)
19688Reader.register('event_subscription', EventSubscriptionReader.read_one)
19689Reader.register('event_subscriptions', EventSubscriptionReader.read_many)
19690Reader.register('external_compute_resource', ExternalComputeResourceReader.read_one)
19691Reader.register('external_compute_resources', ExternalComputeResourceReader.read_many)
19692Reader.register('external_discovered_host', ExternalDiscoveredHostReader.read_one)
19693Reader.register('external_discovered_hosts', ExternalDiscoveredHostReader.read_many)
19694Reader.register('external_host', ExternalHostReader.read_one)
19695Reader.register('external_hosts', ExternalHostReader.read_many)
19696Reader.register('external_host_group', ExternalHostGroupReader.read_one)
19697Reader.register('external_host_groups', ExternalHostGroupReader.read_many)
19698Reader.register('external_host_provider', ExternalHostProviderReader.read_one)
19699Reader.register('external_host_providers', ExternalHostProviderReader.read_many)
19700Reader.register('external_network_provider_configuration', ExternalNetworkProviderConfigurationReader.read_one)
19701Reader.register('external_network_provider_configurations', ExternalNetworkProviderConfigurationReader.read_many)
19702Reader.register('external_provider', ExternalProviderReader.read_one)
19703Reader.register('external_providers', ExternalProviderReader.read_many)
19704Reader.register('external_template_import', ExternalTemplateImportReader.read_one)
19705Reader.register('external_template_imports', ExternalTemplateImportReader.read_many)
19706Reader.register('external_vm_import', ExternalVmImportReader.read_one)
19707Reader.register('external_vm_imports', ExternalVmImportReader.read_many)
19708Reader.register('fault', FaultReader.read_one)
19709Reader.register('faults', FaultReader.read_many)
19710Reader.register('fencing_policy', FencingPolicyReader.read_one)
19711Reader.register('fencing_policies', FencingPolicyReader.read_many)
19712Reader.register('file', FileReader.read_one)
19713Reader.register('files', FileReader.read_many)
19714Reader.register('filter', FilterReader.read_one)
19715Reader.register('filters', FilterReader.read_many)
19716Reader.register('floppy', FloppyReader.read_one)
19717Reader.register('floppies', FloppyReader.read_many)
19718Reader.register('fop_statistic', FopStatisticReader.read_one)
19719Reader.register('fop_statistics', FopStatisticReader.read_many)
19720Reader.register('brick', GlusterBrickReader.read_one)
19721Reader.register('bricks', GlusterBrickReader.read_many)
19722Reader.register('gluster_brick_advanced_details', GlusterBrickAdvancedDetailsReader.read_one)
19723Reader.register('gluster_brick_advanced_detailss', GlusterBrickAdvancedDetailsReader.read_many)
19724Reader.register('brick_memoryinfo', GlusterBrickMemoryInfoReader.read_one)
19725Reader.register('gluster_brick_memory_infos', GlusterBrickMemoryInfoReader.read_many)
19726Reader.register('gluster_client', GlusterClientReader.read_one)
19727Reader.register('gluster_clients', GlusterClientReader.read_many)
19728Reader.register('gluster_hook', GlusterHookReader.read_one)
19729Reader.register('gluster_hooks', GlusterHookReader.read_many)
19730Reader.register('memory_pool', GlusterMemoryPoolReader.read_one)
19731Reader.register('memory_pools', GlusterMemoryPoolReader.read_many)
19732Reader.register('server_hook', GlusterServerHookReader.read_one)
19733Reader.register('server_hooks', GlusterServerHookReader.read_many)
19734Reader.register('gluster_volume', GlusterVolumeReader.read_one)
19735Reader.register('gluster_volumes', GlusterVolumeReader.read_many)
19736Reader.register('gluster_volume_profile_details', GlusterVolumeProfileDetailsReader.read_one)
19737Reader.register('gluster_volume_profile_detailss', GlusterVolumeProfileDetailsReader.read_many)
19738Reader.register('grace_period', GracePeriodReader.read_one)
19739Reader.register('grace_periods', GracePeriodReader.read_many)
19740Reader.register('graphics_console', GraphicsConsoleReader.read_one)
19741Reader.register('graphics_consoles', GraphicsConsoleReader.read_many)
19742Reader.register('group', GroupReader.read_one)
19743Reader.register('groups', GroupReader.read_many)
19744Reader.register('guest_operating_system', GuestOperatingSystemReader.read_one)
19745Reader.register('guest_operating_systems', GuestOperatingSystemReader.read_many)
19746Reader.register('hardware_information', HardwareInformationReader.read_one)
19747Reader.register('hardware_informations', HardwareInformationReader.read_many)
19748Reader.register('high_availability', HighAvailabilityReader.read_one)
19749Reader.register('high_availabilities', HighAvailabilityReader.read_many)
19750Reader.register('hook', HookReader.read_one)
19751Reader.register('hooks', HookReader.read_many)
19752Reader.register('host', HostReader.read_one)
19753Reader.register('hosts', HostReader.read_many)
19754Reader.register('host_cpu_unit', HostCpuUnitReader.read_one)
19755Reader.register('host_cpu_units', HostCpuUnitReader.read_many)
19756Reader.register('host_device', HostDeviceReader.read_one)
19757Reader.register('host_devices', HostDeviceReader.read_many)
19758Reader.register('host_device_passthrough', HostDevicePassthroughReader.read_one)
19759Reader.register('host_device_passthroughs', HostDevicePassthroughReader.read_many)
19760Reader.register('host_nic', HostNicReader.read_one)
19761Reader.register('host_nics', HostNicReader.read_many)
19762Reader.register('host_nic_virtual_functions_configuration', HostNicVirtualFunctionsConfigurationReader.read_one)
19763Reader.register('host_nic_virtual_functions_configurations', HostNicVirtualFunctionsConfigurationReader.read_many)
19764Reader.register('host_storage', HostStorageReader.read_one)
19765Reader.register('host_storages', HostStorageReader.read_many)
19766Reader.register('hosted_engine', HostedEngineReader.read_one)
19767Reader.register('hosted_engines', HostedEngineReader.read_many)
19768Reader.register('icon', IconReader.read_one)
19769Reader.register('icons', IconReader.read_many)
19770Reader.register('identified', IdentifiedReader.read_one)
19771Reader.register('identifieds', IdentifiedReader.read_many)
19772Reader.register('image', ImageReader.read_one)
19773Reader.register('images', ImageReader.read_many)
19774Reader.register('image_transfer', ImageTransferReader.read_one)
19775Reader.register('image_transfers', ImageTransferReader.read_many)
19776Reader.register('initialization', InitializationReader.read_one)
19777Reader.register('initializations', InitializationReader.read_many)
19778Reader.register('instance_type', InstanceTypeReader.read_one)
19779Reader.register('instance_types', InstanceTypeReader.read_many)
19780Reader.register('io', IoReader.read_one)
19781Reader.register('ios', IoReader.read_many)
19782Reader.register('ip', IpReader.read_one)
19783Reader.register('ips', IpReader.read_many)
19784Reader.register('ip_address_assignment', IpAddressAssignmentReader.read_one)
19785Reader.register('ip_address_assignments', IpAddressAssignmentReader.read_many)
19786Reader.register('iscsi_bond', IscsiBondReader.read_one)
19787Reader.register('iscsi_bonds', IscsiBondReader.read_many)
19788Reader.register('iscsi_details', IscsiDetailsReader.read_one)
19789Reader.register('iscsi_detailss', IscsiDetailsReader.read_many)
19790Reader.register('job', JobReader.read_one)
19791Reader.register('jobs', JobReader.read_many)
19792Reader.register('katello_erratum', KatelloErratumReader.read_one)
19793Reader.register('katello_errata', KatelloErratumReader.read_many)
19794Reader.register('kernel', KernelReader.read_one)
19795Reader.register('kernels', KernelReader.read_many)
19796Reader.register('ksm', KsmReader.read_one)
19797Reader.register('ksms', KsmReader.read_many)
19798Reader.register('link_layer_discovery_protocol_element', LinkLayerDiscoveryProtocolElementReader.read_one)
19799Reader.register('link_layer_discovery_protocol_elements', LinkLayerDiscoveryProtocolElementReader.read_many)
19800Reader.register('logical_unit', LogicalUnitReader.read_one)
19801Reader.register('logical_units', LogicalUnitReader.read_many)
19802Reader.register('m_dev_type', MDevTypeReader.read_one)
19803Reader.register('m_dev_types', MDevTypeReader.read_many)
19804Reader.register('mac', MacReader.read_one)
19805Reader.register('macs', MacReader.read_many)
19806Reader.register('mac_pool', MacPoolReader.read_one)
19807Reader.register('mac_pools', MacPoolReader.read_many)
19808Reader.register('memory_over_commit', MemoryOverCommitReader.read_one)
19809Reader.register('memory_over_commits', MemoryOverCommitReader.read_many)
19810Reader.register('memory_policy', MemoryPolicyReader.read_one)
19811Reader.register('memory_policies', MemoryPolicyReader.read_many)
19812Reader.register('method', MethodReader.read_one)
19813Reader.register('methods', MethodReader.read_many)
19814Reader.register('migration_bandwidth', MigrationBandwidthReader.read_one)
19815Reader.register('migration_bandwidths', MigrationBandwidthReader.read_many)
19816Reader.register('migration', MigrationOptionsReader.read_one)
19817Reader.register('migration_optionss', MigrationOptionsReader.read_many)
19818Reader.register('migration_policy', MigrationPolicyReader.read_one)
19819Reader.register('migration_policies', MigrationPolicyReader.read_many)
19820Reader.register('network', NetworkReader.read_one)
19821Reader.register('networks', NetworkReader.read_many)
19822Reader.register('network_attachment', NetworkAttachmentReader.read_one)
19823Reader.register('network_attachments', NetworkAttachmentReader.read_many)
19824Reader.register('network_configuration', NetworkConfigurationReader.read_one)
19825Reader.register('network_configurations', NetworkConfigurationReader.read_many)
19826Reader.register('network_filter', NetworkFilterReader.read_one)
19827Reader.register('network_filters', NetworkFilterReader.read_many)
19828Reader.register('network_filter_parameter', NetworkFilterParameterReader.read_one)
19829Reader.register('network_filter_parameters', NetworkFilterParameterReader.read_many)
19830Reader.register('network_label', NetworkLabelReader.read_one)
19831Reader.register('network_labels', NetworkLabelReader.read_many)
19832Reader.register('nfs_profile_detail', NfsProfileDetailReader.read_one)
19833Reader.register('nfs_profile_details', NfsProfileDetailReader.read_many)
19834Reader.register('nic', NicReader.read_one)
19835Reader.register('nics', NicReader.read_many)
19836Reader.register('nic_configuration', NicConfigurationReader.read_one)
19837Reader.register('nic_configurations', NicConfigurationReader.read_many)
19838Reader.register('host_numa_node', NumaNodeReader.read_one)
19839Reader.register('host_numa_nodes', NumaNodeReader.read_many)
19840Reader.register('numa_node_pin', NumaNodePinReader.read_one)
19841Reader.register('numa_node_pins', NumaNodePinReader.read_many)
19842Reader.register('openstack_image', OpenStackImageReader.read_one)
19843Reader.register('openstack_images', OpenStackImageReader.read_many)
19844Reader.register('openstack_image_provider', OpenStackImageProviderReader.read_one)
19845Reader.register('openstack_image_providers', OpenStackImageProviderReader.read_many)
19846Reader.register('openstack_network', OpenStackNetworkReader.read_one)
19847Reader.register('openstack_networks', OpenStackNetworkReader.read_many)
19848Reader.register('openstack_network_provider', OpenStackNetworkProviderReader.read_one)
19849Reader.register('openstack_network_providers', OpenStackNetworkProviderReader.read_many)
19850Reader.register('open_stack_provider', OpenStackProviderReader.read_one)
19851Reader.register('open_stack_providers', OpenStackProviderReader.read_many)
19852Reader.register('openstack_subnet', OpenStackSubnetReader.read_one)
19853Reader.register('openstack_subnets', OpenStackSubnetReader.read_many)
19854Reader.register('openstack_volume_provider', OpenStackVolumeProviderReader.read_one)
19855Reader.register('openstack_volume_providers', OpenStackVolumeProviderReader.read_many)
19856Reader.register('open_stack_volume_type', OpenStackVolumeTypeReader.read_one)
19857Reader.register('open_stack_volume_types', OpenStackVolumeTypeReader.read_many)
19858Reader.register('openstack_volume_authentication_key', OpenstackVolumeAuthenticationKeyReader.read_one)
19859Reader.register('openstack_volume_authentication_keys', OpenstackVolumeAuthenticationKeyReader.read_many)
19860Reader.register('os', OperatingSystemReader.read_one)
19861Reader.register('oss', OperatingSystemReader.read_many)
19862Reader.register('operating_system', OperatingSystemInfoReader.read_one)
19863Reader.register('operation_systems', OperatingSystemInfoReader.read_many)
19864Reader.register('option', OptionReader.read_one)
19865Reader.register('options', OptionReader.read_many)
19866Reader.register('package', PackageReader.read_one)
19867Reader.register('packages', PackageReader.read_many)
19868Reader.register('payload', PayloadReader.read_one)
19869Reader.register('payloads', PayloadReader.read_many)
19870Reader.register('permission', PermissionReader.read_one)
19871Reader.register('permissions', PermissionReader.read_many)
19872Reader.register('permit', PermitReader.read_one)
19873Reader.register('permits', PermitReader.read_many)
19874Reader.register('pm_proxy', PmProxyReader.read_one)
19875Reader.register('pm_proxies', PmProxyReader.read_many)
19876Reader.register('port_mirroring', PortMirroringReader.read_one)
19877Reader.register('port_mirrorings', PortMirroringReader.read_many)
19878Reader.register('power_management', PowerManagementReader.read_one)
19879Reader.register('power_managements', PowerManagementReader.read_many)
19880Reader.register('product', ProductReader.read_one)
19881Reader.register('products', ProductReader.read_many)
19882Reader.register('product_info', ProductInfoReader.read_one)
19883Reader.register('product_infos', ProductInfoReader.read_many)
19884Reader.register('profile_detail', ProfileDetailReader.read_one)
19885Reader.register('profile_details', ProfileDetailReader.read_many)
19886Reader.register('property', PropertyReader.read_one)
19887Reader.register('properties', PropertyReader.read_many)
19888Reader.register('proxy_ticket', ProxyTicketReader.read_one)
19889Reader.register('proxy_tickets', ProxyTicketReader.read_many)
19890Reader.register('qos', QosReader.read_one)
19891Reader.register('qoss', QosReader.read_many)
19892Reader.register('quota', QuotaReader.read_one)
19893Reader.register('quotas', QuotaReader.read_many)
19894Reader.register('quota_cluster_limit', QuotaClusterLimitReader.read_one)
19895Reader.register('quota_cluster_limits', QuotaClusterLimitReader.read_many)
19896Reader.register('quota_storage_limit', QuotaStorageLimitReader.read_one)
19897Reader.register('quota_storage_limits', QuotaStorageLimitReader.read_many)
19898Reader.register('range', RangeReader.read_one)
19899Reader.register('ranges', RangeReader.read_many)
19900Reader.register('rate', RateReader.read_one)
19901Reader.register('rates', RateReader.read_many)
19902Reader.register('registration_affinity_group_mapping', RegistrationAffinityGroupMappingReader.read_one)
19903Reader.register('registration_affinity_group_mappings', RegistrationAffinityGroupMappingReader.read_many)
19904Reader.register('registration_affinity_label_mapping', RegistrationAffinityLabelMappingReader.read_one)
19905Reader.register('registration_affinity_label_mappings', RegistrationAffinityLabelMappingReader.read_many)
19906Reader.register('registration_cluster_mapping', RegistrationClusterMappingReader.read_one)
19907Reader.register('registration_cluster_mappings', RegistrationClusterMappingReader.read_many)
19908Reader.register('registration_configuration', RegistrationConfigurationReader.read_one)
19909Reader.register('registration_configurations', RegistrationConfigurationReader.read_many)
19910Reader.register('registration_domain_mapping', RegistrationDomainMappingReader.read_one)
19911Reader.register('registration_domain_mappings', RegistrationDomainMappingReader.read_many)
19912Reader.register('registration_lun_mapping', RegistrationLunMappingReader.read_one)
19913Reader.register('registration_lun_mappings', RegistrationLunMappingReader.read_many)
19914Reader.register('registration_role_mapping', RegistrationRoleMappingReader.read_one)
19915Reader.register('registration_role_mappings', RegistrationRoleMappingReader.read_many)
19916Reader.register('registration_vnic_profile_mapping', RegistrationVnicProfileMappingReader.read_one)
19917Reader.register('registration_vnic_profile_mappings', RegistrationVnicProfileMappingReader.read_many)
19918Reader.register('reported_configuration', ReportedConfigurationReader.read_one)
19919Reader.register('reported_configurations', ReportedConfigurationReader.read_many)
19920Reader.register('reported_device', ReportedDeviceReader.read_one)
19921Reader.register('reported_devices', ReportedDeviceReader.read_many)
19922Reader.register('rng_device', RngDeviceReader.read_one)
19923Reader.register('rng_devices', RngDeviceReader.read_many)
19924Reader.register('role', RoleReader.read_one)
19925Reader.register('roles', RoleReader.read_many)
19926Reader.register('scheduling_policy', SchedulingPolicyReader.read_one)
19927Reader.register('scheduling_policies', SchedulingPolicyReader.read_many)
19928Reader.register('scheduling_policy_unit', SchedulingPolicyUnitReader.read_one)
19929Reader.register('scheduling_policy_units', SchedulingPolicyUnitReader.read_many)
19930Reader.register('se_linux', SeLinuxReader.read_one)
19931Reader.register('se_linuxs', SeLinuxReader.read_many)
19932Reader.register('serial_number', SerialNumberReader.read_one)
19933Reader.register('serial_numbers', SerialNumberReader.read_many)
19934Reader.register('session', SessionReader.read_one)
19935Reader.register('sessions', SessionReader.read_many)
19936Reader.register('skip_if_connectivity_broken', SkipIfConnectivityBrokenReader.read_one)
19937Reader.register('skip_if_connectivity_brokens', SkipIfConnectivityBrokenReader.read_many)
19938Reader.register('skip_if_sd_active', SkipIfSdActiveReader.read_one)
19939Reader.register('skip_if_sd_actives', SkipIfSdActiveReader.read_many)
19940Reader.register('snapshot', SnapshotReader.read_one)
19941Reader.register('snapshots', SnapshotReader.read_many)
19942Reader.register('special_objects', SpecialObjectsReader.read_one)
19943Reader.register('special_objectss', SpecialObjectsReader.read_many)
19944Reader.register('spm', SpmReader.read_one)
19945Reader.register('spms', SpmReader.read_many)
19946Reader.register('ssh', SshReader.read_one)
19947Reader.register('sshs', SshReader.read_many)
19948Reader.register('ssh_public_key', SshPublicKeyReader.read_one)
19949Reader.register('ssh_public_keys', SshPublicKeyReader.read_many)
19950Reader.register('sso', SsoReader.read_one)
19951Reader.register('ssos', SsoReader.read_many)
19952Reader.register('statistic', StatisticReader.read_one)
19953Reader.register('statistics', StatisticReader.read_many)
19954Reader.register('step', StepReader.read_one)
19955Reader.register('steps', StepReader.read_many)
19956Reader.register('storage_connection', StorageConnectionReader.read_one)
19957Reader.register('storage_connections', StorageConnectionReader.read_many)
19958Reader.register('storage_connection_extension', StorageConnectionExtensionReader.read_one)
19959Reader.register('storage_connection_extensions', StorageConnectionExtensionReader.read_many)
19960Reader.register('storage_domain', StorageDomainReader.read_one)
19961Reader.register('storage_domains', StorageDomainReader.read_many)
19962Reader.register('storage_domain_lease', StorageDomainLeaseReader.read_one)
19963Reader.register('storage_domain_leases', StorageDomainLeaseReader.read_many)
19964Reader.register('system_option', SystemOptionReader.read_one)
19965Reader.register('system_options', SystemOptionReader.read_many)
19966Reader.register('system_option_value', SystemOptionValueReader.read_one)
19967Reader.register('system_option_values', SystemOptionValueReader.read_many)
19968Reader.register('tag', TagReader.read_one)
19969Reader.register('tags', TagReader.read_many)
19970Reader.register('template', TemplateReader.read_one)
19971Reader.register('templates', TemplateReader.read_many)
19972Reader.register('template_version', TemplateVersionReader.read_one)
19973Reader.register('template_versions', TemplateVersionReader.read_many)
19974Reader.register('ticket', TicketReader.read_one)
19975Reader.register('tickets', TicketReader.read_many)
19976Reader.register('time_zone', TimeZoneReader.read_one)
19977Reader.register('time_zones', TimeZoneReader.read_many)
19978Reader.register('transparent_hugepages', TransparentHugePagesReader.read_one)
19979Reader.register('transparent_huge_pagess', TransparentHugePagesReader.read_many)
19980Reader.register('unmanaged_network', UnmanagedNetworkReader.read_one)
19981Reader.register('unmanaged_networks', UnmanagedNetworkReader.read_many)
19982Reader.register('usb', UsbReader.read_one)
19983Reader.register('usbs', UsbReader.read_many)
19984Reader.register('user', UserReader.read_one)
19985Reader.register('users', UserReader.read_many)
19986Reader.register('user_option', UserOptionReader.read_one)
19987Reader.register('user_options', UserOptionReader.read_many)
19988Reader.register('value', ValueReader.read_one)
19989Reader.register('values', ValueReader.read_many)
19990Reader.register('vcpu_pin', VcpuPinReader.read_one)
19991Reader.register('vcpu_pins', VcpuPinReader.read_many)
19992Reader.register('vendor', VendorReader.read_one)
19993Reader.register('vendors', VendorReader.read_many)
19994Reader.register('version', VersionReader.read_one)
19995Reader.register('versions', VersionReader.read_many)
19996Reader.register('virtio_scsi', VirtioScsiReader.read_one)
19997Reader.register('virtio_scsis', VirtioScsiReader.read_many)
19998Reader.register('vm_numa_node', VirtualNumaNodeReader.read_one)
19999Reader.register('vm_numa_nodes', VirtualNumaNodeReader.read_many)
20000Reader.register('vlan', VlanReader.read_one)
20001Reader.register('vlans', VlanReader.read_many)
20002Reader.register('vm', VmReader.read_one)
20003Reader.register('vms', VmReader.read_many)
20004Reader.register('vm_base', VmBaseReader.read_one)
20005Reader.register('vm_bases', VmBaseReader.read_many)
20006Reader.register('vm_mediated_device', VmMediatedDeviceReader.read_one)
20007Reader.register('vm_mediated_devices', VmMediatedDeviceReader.read_many)
20008Reader.register('vm_placement_policy', VmPlacementPolicyReader.read_one)
20009Reader.register('vm_placement_policies', VmPlacementPolicyReader.read_many)
20010Reader.register('vm_pool', VmPoolReader.read_one)
20011Reader.register('vm_pools', VmPoolReader.read_many)
20012Reader.register('vm_summary', VmSummaryReader.read_one)
20013Reader.register('vm_summaries', VmSummaryReader.read_many)
20014Reader.register('vnic_pass_through', VnicPassThroughReader.read_one)
20015Reader.register('vnic_pass_throughs', VnicPassThroughReader.read_many)
20016Reader.register('vnic_profile', VnicProfileReader.read_one)
20017Reader.register('vnic_profiles', VnicProfileReader.read_many)
20018Reader.register('vnic_profile_mapping', VnicProfileMappingReader.read_one)
20019Reader.register('vnic_profile_mappings', VnicProfileMappingReader.read_many)
20020Reader.register('volume_group', VolumeGroupReader.read_one)
20021Reader.register('volume_groups', VolumeGroupReader.read_many)
20022Reader.register('watchdog', WatchdogReader.read_one)
20023Reader.register('watchdogs', WatchdogReader.read_many)
20024Reader.register('weight', WeightReader.read_one)
20025Reader.register('weights', WeightReader.read_many)